diff --git a/config_automation.yml b/config_automation.yml
index 4224739..0ea533c 100644
--- a/config_automation.yml
+++ b/config_automation.yml
@@ -21,9 +21,9 @@ render-website: rmd
 render-leanpub: yes
 render-coursera: no
 
-## Automate the creation of Book.txt file? TRUE/FALSE?
+## Automate the creation of Book.txt file? yes/no
 ## This is only relevant if render-leanpub is yes, otherwise it will be ignored
-make-book-txt: TRUE
+make-book-txt: yes
 
 # What docker image should be used for rendering?
 # The default is jhudsl/base_ottr:main
diff --git a/docs/01-intro-to-computing.md b/docs/01-intro-to-computing.md
index ebcf137..cc8d4ee 100644
--- a/docs/01-intro-to-computing.md
+++ b/docs/01-intro-to-computing.md
@@ -38,11 +38,13 @@ More importantly: **How we organize ideas \<-\> Instructing a computer to do som
 
 Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user.
 
-Let's open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named "KRAS Demo" in your Google Classroom workspace. If you are taking this course on your own time, open up...
+Let's open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named "KRAS Demo" in your Google Classroom workspace. If you are taking this course on your own time, you can view it [here](https://colab.research.google.com/drive/1_77QQcj0mgZOWLlhtkZ-QKWUP1dnSt-_?usp=sharing).
+
+![](images/colab.png){width="800"}
 
 Today, we will pay close attention to:
 
--   Python Console (Execution): Open it via View -\> Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.
+-   Python Console ("Executions"): Open it via View -\> Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.
 
 -   Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text *and* Python code, and it helps us understand better the code we are writing.
 
@@ -50,7 +52,7 @@ Today, we will pay close attention to:
 
 The first thing we will do is see the different ways we can run Python code. You can do the following:
 
-1.  Type something into the Python Console (Execution) and type enter, such as `2+2`. The Python Console will run it and give you an output.
+1.  Type something into the Python Console (Execution) and click the arrow button, such as `2+2`. The Python Console will run it and give you an output.
 2.  Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data.
 3.  Run every single Python code chunk via Runtime -\> Run all.
 
@@ -66,13 +68,15 @@ Python Notebook is great for data science work, because:
 
 -   It is flexible to use other programming languages, such as R.
 
+The version of Python used in this course and in Google Colab is Python 3, which is the version of Python that is most supported. Some Python software is written in Python 2, which is very similar but has some [notable differences](https://www.fullstackpython.com/python-2-or-3.html).
+
 Now, we will get to the basics of programming grammar.
 
 ## Grammar Structure 1: Evaluation of Expressions
 
 -   **Expressions** are be built out of **operations** or **functions**.
 
--   Functions and operations take in **data types**, do something with them, and return another data type.
+-   Functions and operations take in **data types** as inputs, do something with them, and **return** another data type as ouput.
 
 -   We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it.
 
@@ -142,7 +146,19 @@ add(18, add(21, 65))
 ## 104
 ```
 
-Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to *readable* code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Because the `add()` function isn't typically used, it is not automatically available, so we used the import statement to load it in.)
+Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to *readable* code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Most functions in Python are stored in a collection of functions called **modules** that needs to be loaded. The `import` statement gives us permission to access the functions in the module "operator".)
+
+### Function machine schema
+
+A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:
+
+![Function machine from algebra class.](images/function_machine.png)
+
+Here are some aspects of this schema to pay attention to:
+
+-   A programmer should not need to know how the function or operation is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.
+
+-   A function can have different kinds of inputs and outputs - it doesn't need to be numbers. In the `len()` function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.
 
 ### Data types
 
@@ -155,16 +171,6 @@ Here are some common data types we will be using in this course.
 | String         |           str           | "hello", "234-234-8594" |
 | Boolean        |          bool           |       True, False       |
 
-A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:
-
-![Function machine from algebra class.](images/function_machine.png)
-
-Here are some aspects of this schema to pay attention to:
-
--   A programmer should not need to know how the function is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.
-
--   A function can have different kinds of inputs and outputs - it doesn't need to be numbers. In the `len()` function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.
-
 ## Grammar Structure 2: Storing data types in the Variable Environment
 
 To build up a computer program, we need to store our returned data type from our expression somewhere for downstream use. We can assign a variable to it as follows:
@@ -182,11 +188,11 @@ If you enter this in the Console, you will see that in the Variable Environment,
 >
 > Bind variable to the left of `=` to the resulting value.
 >
-> The variable is stored in the Variable Environment.
+> The variable is stored in the **Variable Environment**.
 
 The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined.
 
-The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. When we work with large datasets, if you assign a variable to a data type larger than the available RAM, it will not work. More on this later.
+The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM.
 
 Look, now `x` can be reused downstream:
 
@@ -203,7 +209,7 @@ x - 2
 y = x * 2
 ```
 
-It is quite common for programmers to not know what data type a variable is while they are coding. To learn about the data type of a variable, use the `type()` function on any variable in Python:
+It is quite common for programmers to have to look up the data type of a variable while they are coding. To learn about the data type of a variable, use the `type()` function on any variable in Python:
 
 
 ``` python
@@ -214,7 +220,7 @@ type(y)
 ## <class 'int'>
 ```
 
-We should give useful variable names so that we know what to expect! Consider `num_sales` instead of `y`.
+We should give useful variable names so that we know what to expect! If you are working with numerical sales data, consider `num_sales` instead of `y`.
 
 ## Grammar Structure 3: Evaluation of Functions
 
@@ -222,22 +228,30 @@ Let's look at functions a little bit more formally: A function has a **function
 
 ### Execution rule for functions:
 
-> Evaluate the function by its arguments, and if the arguments are functions or contains operations, evaluate those functions or operations first.
+> Evaluate the function by its arguments if there's any, and if the arguments are functions or contains operations, evaluate those functions or operations first.
 >
 > The output of functions is called the **returned value**.
 
-Often, we will use multiple functions, in a nested way, or use parenthesis to change the order of operation. Being able to read nested operations, nested functions, and parenthesis is very important. Think about what the Python is going to do step-by--step in the line of code below:
+Often, we will use multiple functions in a nested way, and it is important to understand how the Python console understand the order of operation. We can also use parenthesis to change the order of operation. Think about what the Python is going to do step-by--step in the lines of code below:
+
+
+``` python
+max(len("hello"), 4)
+```
 
+```
+## 5
+```
 
 ``` python
-(len("hello") + 4) * 2
+(len("pumpkin") - 8) * 2
 ```
 
 ```
-## 18
+## -2
 ```
 
-If we don't know how to use a function, such as `pow()` we can ask for help:
+If we don't know how to use a function, such as `pow()`, we can ask for help:
 
 ```         
 ?pow
@@ -249,7 +263,9 @@ Some types, such as ints, are able to use a more efficient algorithm when
 invoked using the three argument form.
 ```
 
-This shows the function takes in three input arguments: `base`, `exp`, and `mod=None`. When an argument has an assigned value of `mod=None`, that means the input argument already has a value, and you don't need to specify anything, unless you want to.
+We can also find a similar help document, in a [nicer rendered form online.](https://docs.python.org/3/library/functions.html#pow) We will practice looking at function documentation throughout the course, because that is a fundamental skill to learn more functions on your own.
+
+The documentation shows the function takes in three input arguments: `base`, `exp`, and `mod=None`. When an argument has an assigned value of `mod=None`, that means the input argument already has a value, and you don't need to specify anything, unless you want to.
 
 The following ways are equivalent ways of using the `pow()` function:
 
@@ -300,13 +316,23 @@ And there is an operational equivalent:
 ## 8
 ```
 
+We will mostly look at functions with input arguments and return types in this course, but not all functions need to have input arguments and output return. Let's look at some examples of functions that don't always have an input or output:
+
+| Function call                                                             | What it takes in         | What it does                                                  | Returns |
+|---------------------------------------------------------------------------|--------------------------|---------------------------------------------------------------|---------|
+| [`pow(a, b)`](https://docs.python.org/3/library/functions.html#pow)       | integer `a`, integer `b` | Raises `a` to the `b`th power.                                | Integer |
+| [`time.sleep(x)`](https://docs.python.org/3/library/time.html#time.sleep) | Integer `x`              | Waits for `x` seconds.                                        | None    |
+| [`dir()`](https://docs.python.org/3/library/functions.html#dir)           | Nothing                  | Gives a list of all the variables defined in the environment. | List    |
+
 ## Tips on writing your first code
 
 `Computer = powerful + stupid`
 
-Even the smallest spelling and formatting changes will cause unexpected output and errors!
+Computers are excellent at doing something specific over and over again, but is extremely rigid and lack flexibility. Here are some tips that is helpful for beginners:
+
+-   Write incrementally, test often.
 
--   Write incrementally, test often
+-   Don't be afraid to break things: it is how we learn how things work in programming.
 
 -   Check your assumptions, especially using new functions, operations, and new data types.
 
@@ -315,3 +341,7 @@ Even the smallest spelling and formatting changes will cause unexpected output a
 -   Ask for help!
 
 To get more familiar with the errors Python gives you, take a look at this [summary of Python error messages](https://betterstack.com/community/guides/scaling-python/python-errors/).
+
+## Exercises
+
+Exercise for week 1 can be found [here](https://colab.research.google.com/drive/1AqVvktGz3LStUyu6dLJFsU2KoqNxgagT?usp=sharing).
diff --git a/docs/02-data-structures.md b/docs/02-data-structures.md
new file mode 100644
index 0000000..bd24e0d
--- /dev/null
+++ b/docs/02-data-structures.md
@@ -0,0 +1,408 @@
+
+
+# Working with data structures
+
+In our second lesson, we start to look at two **data structures**, **Lists** and **Dataframes**, that can handle a large amount of data for analysis.
+
+## Lists
+
+In the first exercise, you started to explore **data structures**, which store information about data types. You explored **lists**, which is an ordered collection of data types or data structures. Each *element* of a list contains a data type or another data structure.
+
+We can now store a vast amount of information in a list, and assign it to a single variable. Even more, we can use operations and functions on a list, modifying many elements within the list at once! This makes analyzing data much more scalable and less repetitive.
+
+We create a list via the bracket `[ ]` operation.
+
+
+``` python
+staff = ["chris", "ted", "jeff"]
+chrNum = [2, 3, 1, 2, 2]
+mixedList = [False, False, False, "A", "B", 92]
+```
+
+### Subsetting lists
+
+To access an element of a list, you can use the bracket notation `[ ]` to access the elements of the list. We simply access an element via the "index" number - the location of the data within the list.
+
+*Here's the tricky thing about the index number: it starts at 0!*
+
+1st element of `chrNum`: `chrNum[0]`
+
+2nd element of `chrNum`: `chrNum[1]`
+
+...
+
+5th element of `chrNum`: `chrNum[4]`
+
+With subsetting, you can modify elements of a list or use the element of a list as part of an expression.
+
+### Subsetting multiple elements of lists
+
+Suppose you want to access multiple elements of a list, such as accessing the first three elements of `chrNum`. You would use the **slice** operator `:`, which specifies:
+
+-   the index number to start
+
+-   the index number to stop, *plus one.*
+
+If you want to access the first three elements of `chrNum`:
+
+
+``` python
+chrNum[0:3]
+```
+
+```
+## [2, 3, 1]
+```
+
+The first element's index number is 0, the third element's index number is 2, plus 1, which is 3.
+
+If you want to access the second and third elements of `chrNum`:
+
+
+``` python
+chrNum[1:3]
+```
+
+```
+## [3, 1]
+```
+
+Another way of accessing the first 3 elements of `chrNum`:
+
+
+``` python
+chrNum[:3]
+```
+
+```
+## [2, 3, 1]
+```
+
+Here, the start index number was not specified. When the start or stop index is *not* specified, it implies that you are subsetting starting the from the beginning of the list or subsetting to the end of the list, respectively. Here's another example, using negative indicies to count from 3 elements from the end of the list:
+
+
+``` python
+chrNum[-3:]
+```
+
+```
+## [1, 2, 2]
+```
+
+You can find more discussion of list slicing, using negative indicies and incremental slicing, [here](https://towardsdatascience.com/the-basics-of-indexing-and-slicing-python-lists-2d12c90a94cf).
+
+## Objects in Python
+
+The list data structure has an organization and functionality that metaphorically represents a pen-and-paper list in our physical world. Like a physical object, we have examined:
+
+-   What does it contain (in terms of data)?
+
+-   What can it do (in terms of functions)?
+
+And if it "makes sense" to us, then it is well-designed.
+
+The list data structure we have been working with is an example of an **Object**. The definition of an object allows us to ask the questions above: *what does it contain, and what can it do?* It is an organizational tool for a collection of data and functions that we can relate to, like a physical object. Formally, an object contains the following:
+
+-   **Value** that holds the essential data for the object.
+
+-   **Attributes** that hold subset or additional data for the object.
+
+-   Functions called **Methods** that are for the object and *have to* take in the variable referenced as an input
+
+This organizing structure on an object applies to pretty much all Python data types and data structures.
+
+Let's see how this applies to the list:
+
+-   **Value**: the contents of the list, such as `[2, 3, 4].`
+
+-   **Attributes** that store additional values: Not relevant for lists.
+
+-   **Methods** that can be used on the object: `chrNum.count(2)` counts the number of instances 2 appears as an element of `chrNum`.
+
+Object methods are functions that does something with the object you are using it on. You should think about `chrNum.count(2)` as a function that takes in `chrNum` and `2` as inputs. If you want to use the count function on list `mixedList`, you would use `mixedList.count(x)`.
+
+Here are some more examples of methods with lists:
+
+| Function method                                                              | What it takes in             | What it does                                                          | Returns                          |
+|---------------|---------------|---------------------------|---------------|
+| [`chrNum.count(x)`](https://docs.python.org/3/tutorial/datastructures.html)  | list `chrNum`, data type `x` | Counts the number of instances `x` appears as an element of `chrNum`. | Integer                          |
+| [`chrNum.append(x)`](https://docs.python.org/3/tutorial/datastructures.html) | list `chrNum`, data type `x` | Appends `x` to the end of the `chrNum`.                               | None (but `chrNum` is modified!) |
+| [`chrNum.sort()`](https://docs.python.org/3/tutorial/datastructures.html)    | list `chrNum`                | Sorts `chrNum` by ascending order.                                    | None (but `chrNum` is modified!) |
+| [`chrNum.reverse()`](https://docs.python.org/3/tutorial/datastructures.html) | list `chrNum`                | Reverses the order of `chrNum`.                                       | None (but `chrNum` is modified!) |
+
+## Methods vs Functions
+
+**Methods** *have to* take in the object of interest as an input: `chrNum.count(2)` automatically treat `chrNum` as an input. Methods are built for a specific Object type.
+
+**Functions** do not have an implied input: `len(chrNum)` requires specifying a list in the input.
+
+Otherwise, there is no strong distinction between the two.
+
+## Dataframes
+
+A Dataframe is a two-dimensional data structure that stores data like a spreadsheet does.
+
+The Dataframe data structure is found within a Python module called "Pandas". A Python module is an organized collection of functions and data structures. The `import` statement below gives us permission to access the "Pandas" module via the variable `pd`.
+
+To load in a Dataframe from existing spreadsheet data, we use the function [`pd.read_csv()`](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html):
+
+
+``` python
+import pandas as pd
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+type(metadata)
+```
+
+```
+## <class 'pandas.core.frame.DataFrame'>
+```
+
+There is a similar function [`pd.read_excel()`](https://pandas.pydata.org/docs/reference/api/pandas.read_excel.html) for loading in Excel spreadsheets.
+
+Let's investigate the Dataframe as an object:
+
+-   What does a Dataframe contain (values, attributes)?
+
+-   What can a Dataframe do (methods)?
+
+## What does a Dataframe contain?
+
+We first take a look at the contents:
+
+
+``` python
+metadata
+```
+
+```
+##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]
+```
+
+It looks like there are 1864 rows and 30 columns in this Dataframe, and when we display it it shows some of the data.
+
+
+``` python
+metadata
+```
+
+```
+##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]
+```
+
+We can look at specific columns by looking at **attributes** via the dot operation. We can also look at the columns via the bracket operation.
+
+
+``` python
+metadata.ModelID
+```
+
+```
+## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object
+```
+
+``` python
+metadata['ModelID']
+```
+
+```
+## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object
+```
+
+The names of all columns is stored as an attribute, which can be accessed via the dot operation.
+
+
+``` python
+metadata.columns
+```
+
+```
+## Index(['ModelID', 'PatientID', 'CellLineName', 'StrippedCellLineName', 'Age',
+##        'SourceType', 'SangerModelID', 'RRID', 'DepmapModelType', 'AgeCategory',
+##        'GrowthPattern', 'LegacyMolecularSubtype', 'PrimaryOrMetastasis',
+##        'SampleCollectionSite', 'Sex', 'SourceDetail', 'LegacySubSubtype',
+##        'CatalogNumber', 'CCLEName', 'COSMICID', 'PublicComments',
+##        'WTSIMasterCellID', 'EngineeredModel', 'TreatmentStatus',
+##        'OnboardedMedia', 'PlateCoating', 'OncotreeCode', 'OncotreeSubtype',
+##        'OncotreePrimaryDisease', 'OncotreeLineage'],
+##       dtype='object')
+```
+
+The number of rows and columns are also stored as an attribute:
+
+
+``` python
+metadata.shape
+```
+
+```
+## (1864, 30)
+```
+
+## What can a Dataframe do?
+
+We can use the [`.head()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.head.html) and [`.tail()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.tail.html) methods to look at the first few rows and last few rows of `metadata`, respectively:
+
+
+``` python
+metadata.head()
+```
+
+```
+##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]
+```
+
+``` python
+metadata.tail()
+```
+
+```
+##          ModelID  PatientID  ...          OncotreePrimaryDisease    OncotreeLineage
+## 1859  ACH-002968  PT-pjhrsc  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1860  ACH-002972  PT-dkXZB1  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1861  ACH-002979  PT-lyHTzo  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1862  ACH-002981  PT-Z9akXf  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1863  ACH-003071  PT-LAGmLq  ...       Lung Neuroendocrine Tumor               Lung
+## 
+## [5 rows x 30 columns]
+```
+
+Both of these functions (without input arguments) are considered as **methods**: they are functions that does something with the Dataframe you are using it on. You should think about `metadata.head()` as a function that takes in `metadata` as an input. If we had another Dataframe called `my_data` and you want to use the same function, you will have to say `my_data.head()`.
+
+## Subsetting Dataframes 
+
+Perhaps the most important operation you will can do with Dataframes is subsetting them. There are two ways to do it. The first way is to subset by numerical indicies, exactly like how we did for lists.
+
+You will use the [`iloc`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html) attribute and bracket operations, and you give two slices: one for the row, and one for the column.
+
+Let's start with a small dataframe to see how it works before returning to `metadata`:
+
+
+``` python
+df = pd.DataFrame(data={'status': ["treated", "untreated", "untreated", "discharged", "treated"],
+                            'age_case': [25, 43, 21, 65, 7],
+                            'age_control': [49, 20, 32, 25, 32]})
+df
+```
+
+```
+##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32
+```
+
+Here is how the dataframe looks like with the row and column index numbers:
+
+![](images/pandas_subset_0.png)
+
+Subset the first fourth rows, and the first two columns:
+
+![](images/pandas subset_1.png)
+
+Now, back to `metadata` dataframe:
+
+Subset the first 5 rows, and first two columns:
+
+
+``` python
+metadata.iloc[:5, :2]
+```
+
+```
+##       ModelID  PatientID
+## 0  ACH-000001  PT-gj46wT
+## 1  ACH-000002  PT-5qa3uk
+## 2  ACH-000003  PT-puKIyc
+## 3  ACH-000004  PT-q4K2cp
+## 4  ACH-000005  PT-q4K2cp
+```
+
+If we want a custom slice that is not sequential, we can use an integer list. Subset the last 5 rows, and the 1st and 10 and 21th column:
+
+
+``` python
+metadata.iloc[5:, [1, 10, 21]]
+```
+
+```
+##       PatientID GrowthPattern  WTSIMasterCellID
+## 5     PT-ej13Dz    Suspension            2167.0
+## 6     PT-NOXwpH      Adherent             569.0
+## 7     PT-fp8PeY      Adherent            1806.0
+## 8     PT-puKIyc      Adherent            2104.0
+## 9     PT-AR7W9o      Adherent               NaN
+## ...         ...           ...               ...
+## 1859  PT-pjhrsc      Organoid               NaN
+## 1860  PT-dkXZB1      Organoid               NaN
+## 1861  PT-lyHTzo      Organoid               NaN
+## 1862  PT-Z9akXf      Organoid               NaN
+## 1863  PT-LAGmLq    Suspension               NaN
+## 
+## [1859 rows x 3 columns]
+```
+
+When we subset via numerical indicies, it's called **explicit subsetting**. This is a great way to start thinking about subsetting your dataframes for analysis, but explicit subsetting can lead to some inconsistencies in the long run. For instance, suppose your collaborator added a new cell line to the metadata and changed the order of the column. Then your code to subset the last 5 rows and the columns will get you a different answer once the spreadsheet is changed.
+
+The second way is to subset by the column name and comparison operators, also known as **implicit subsetting**. This is much more robust in data analysis practice. You will learn about it next week!
+
+## Exercises
+
+Exercise for week 2 can be found [here](https://colab.research.google.com/drive/1oIL3gKEZR2Lq16k6XY0HXIhjYl34pEjr?usp=sharing).
diff --git a/docs/03-data-wrangling1.md b/docs/03-data-wrangling1.md
new file mode 100644
index 0000000..7e8578e
--- /dev/null
+++ b/docs/03-data-wrangling1.md
@@ -0,0 +1,354 @@
+
+
+# Data Wrangling, Part 1
+
+From our first two lessons, we are now equipped with enough fundamental programming skills to apply it to various steps in the data science workflow, which is a natural cycle that occurs in data analysis.
+
+![Data science workflow. Image source: R for Data Science.](https://d33wubrfki0l68.cloudfront.net/571b056757d68e6df81a3e3853f54d3c76ad6efc/32d37/diagrams/data-science.png){width="550"}
+
+For the rest of the course, we focus on *Transform* and *Visualize* with the assumption that our data is in a nice, "Tidy format". First, we need to understand what it means for a data to be "Tidy".
+
+## Tidy Data
+
+Here, we describe a standard of organizing data. It is important to have standards, as it facilitates a consistent way of thinking about data organization and building tools (functions) that make use of that standard. The principles of **tidy data**, developed by Hadley Wickham:
+
+1.  Each variable must have its own column.
+
+2.  Each observation must have its own row.
+
+3.  Each value must have its own cell.
+
+If you want to be technical about what variables and observations are, Hadley Wickham describes:
+
+> A **variable** contains all values that measure the same underlying attribute (like height, temperature, duration) across units. An **observation** contains all values measured on the same unit (like a person, or a day, or a race) across attributes.
+
+![A tidy dataframe. Image source: R for Data Science.](https://r4ds.hadley.nz/images/tidy-1.png){width="800"}
+
+## Our working Tidy Data: DepMap Project
+
+The [Dependency Map project](https://depmap.org/portal/) is a multi-omics profiling of cancer cell lines combined with functional assays such as CRISPR and drug sensitivity to help identify cancer vulnerabilities and drug targets. Here are some of the data that we have public access to. We have been looking at the metadata since last session.
+
+-   Metadata
+
+-   Somatic mutations
+
+-   Gene expression
+
+-   Drug sensitivity
+
+-   CRISPR knockout
+
+-   and more...
+
+Let's load these datasets in, and see how these datasets fit the definition of Tidy data:
+
+
+``` python
+import pandas as pd
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+mutation = pd.read_csv("classroom_data/mutation.csv")
+expression = pd.read_csv("classroom_data/expression.csv")
+```
+
+
+``` python
+metadata.head()
+```
+
+```
+##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]
+```
+
+
+``` python
+mutation.head()
+```
+
+```
+##       ModelID  CACNA1D_Mut  CYP2D6_Mut  ...  CCDC28A_Mut  C1orf194_Mut  U2AF1_Mut
+## 0  ACH-000001        False       False  ...        False         False      False
+## 1  ACH-000002        False       False  ...        False         False      False
+## 2  ACH-000004        False       False  ...        False         False      False
+## 3  ACH-000005        False       False  ...        False         False      False
+## 4  ACH-000006        False       False  ...        False         False      False
+## 
+## [5 rows x 540 columns]
+```
+
+
+``` python
+expression.head()
+```
+
+```
+##       ModelID  ENPP4_Exp  CREBBP_Exp  ...  OR5D13_Exp  C2orf81_Exp  OR8S1_Exp
+## 0  ACH-001113   2.280956    4.094236  ...         0.0     1.726831        0.0
+## 1  ACH-001289   3.622930    3.606442  ...         0.0     0.790772        0.0
+## 2  ACH-001339   0.790772    2.970854  ...         0.0     0.575312        0.0
+## 3  ACH-001538   3.485427    2.801159  ...         0.0     1.077243        0.0
+## 4  ACH-000242   0.879706    3.327687  ...         0.0     0.722466        0.0
+## 
+## [5 rows x 536 columns]
+```
+
+| Dataframe  | The observation is | Some variables are            | Some values are             |
+|-----------------|-----------------|--------------------|------------------|
+| metadata   | Cell line          | ModelID, Age, OncotreeLineage | "ACH-000001", 60, "Myeloid" |
+| expression | Cell line          | KRAS_Exp                      | 2.4, .3                     |
+| mutation   | Cell line          | KRAS_Mut                      | TRUE, FALSE                 |
+
+## Transform: "What do you want to do with this Dataframe"?
+
+Remember that a major theme of the course is about: **How we organize ideas \<-\> Instructing a computer to do something.**
+
+Until now, we haven't focused too much on how we organize our scientific ideas to interact with what we can do with code. Let's pivot to write our code driven by our scientific curiosity. After we are sure that we are working with Tidy data, we can ponder how we want to transform our data that satisfies our scientific question. We will look at several ways we can transform Tidy data, starting with subsetting columns and rows.
+
+Here's a starting prompt:
+
+> In the `metadata` dataframe, which rows would you subset for and columns would you subset for that relate to a scientific question?
+
+We have been using **explicit subsetting** with numerical indicies, such as "I want to filter for rows 20-50 and select columns 2 and 8". We are now going to switch to **implicit subsetting** in which we describe the subsetting criteria via comparision operators and column names, such as:
+
+*"I want to subset for rows such that the OncotreeLineage is breast cancer and subset for columns Age and Sex."*
+
+Notice that when we subset for rows in an implicit way, we formulate our criteria in terms of the columns.This is because we are guaranteed to have column names in Dataframes, but not row names.
+
+#### Let's convert our implicit subsetting criteria into code!
+
+To subset for rows implicitly, we will use the conditional operators on Dataframe columns you used in Exercise 2. To formulate a conditional operator expression that OncotreeLineage is breast cancer:
+
+
+``` python
+metadata['OncotreeLineage'] == "Lung"
+```
+
+```
+## 0       False
+## 1       False
+## 2       False
+## 3       False
+## 4       False
+##         ...  
+## 1859    False
+## 1860    False
+## 1861    False
+## 1862    False
+## 1863     True
+## Name: OncotreeLineage, Length: 1864, dtype: bool
+```
+
+Then, we will use the [`.loc`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html) operation (which is different than [`.iloc`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html) operation!) and subsetting brackets to subset rows and columns Age and Sex at the same time:
+
+
+``` python
+metadata.loc[metadata['OncotreeLineage'] == "Lung", ["Age", "Sex"]]
+```
+
+```
+##        Age     Sex
+## 10    39.0  Female
+## 13    44.0    Male
+## 19    55.0  Female
+## 27    39.0  Female
+## 28    45.0    Male
+## ...    ...     ...
+## 1745  52.0    Male
+## 1819  84.0    Male
+## 1820  57.0  Female
+## 1822  53.0    Male
+## 1863  62.0    Male
+## 
+## [241 rows x 2 columns]
+```
+
+What's going on here? The first component of the subset, `metadata['OncotreeLineage'] == "Lung"`, subsets for the rows. It gives us a column of `True` and `False` values, and we keep rows that correspond to `True` values. Then, we specify the column names we want to subset for via a list.
+
+Here's another example:
+
+
+``` python
+df = pd.DataFrame(data={'status': ["treated", "untreated", "untreated", "discharged", "treated"],
+                            'age_case': [25, 43, 21, 65, 7],
+                            'age_control': [49, 20, 32, 25, 32]})
+                            
+df
+```
+
+```
+##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32
+```
+
+*"I want to subset for rows such that the status is"treated" and subset for columns status and age_case."*
+
+
+``` python
+df.loc[df.status == "treated", ["status", "age_case"]]
+```
+
+```
+##     status  age_case
+## 0  treated        25
+## 4  treated         7
+```
+
+![](images/pandas_subset_2.png)
+
+## Summary Statistics
+
+Now that your Dataframe has be transformed based on your scientific question, you can start doing some analysis on it! A common data science task is to examine summary statistics of a dataset, which summarizes the all the values from a variable in a numeric summary, such as mean, median, or mode.
+
+If we look at the data structure of a Dataframe's column, it is actually not a List, but an object called Series. It has methods can compute summary statistics for us. Let's take a look at a few popular examples:
+
+| Function method                                                                                                           | What it takes in                              | What it does                                                                  | Returns       |
+|----------------|----------------|------------------------|----------------|
+| [`metadata.Age.mean()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.mean.html)                             | `metadata.Age` as a numeric Series            | Computes the mean value of the `Age` column.                                  | Float (NumPy) |
+| [`metadata['Age'].median()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.median.html)                      | `metadata['Age']` as a numeric Series         | Computes the median value of the `Age` column.                                | Float (NumPy) |
+| [`metadata.Age.max()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.max.html)                               | `metadata.Age` as a numeric Series            | Computes the max value of the `Age` column.                                   | Float (NumPy) |
+| [`metadata.OncotreeSubtype.value_counts()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.value_counts.html) | `metadata.OncotreeSubtype` as a string Series | Creates a frequency table of all unique elements in `OncotreeSubtype` column. | Series        |
+
+Let's try it out, with some nice print formatting:
+
+
+``` python
+print("Mean value of Age column:", metadata['Age'].mean())
+```
+
+```
+## Mean value of Age column: 47.45187165775401
+```
+
+``` python
+print("Frequency of column", metadata.OncotreeLineage.value_counts())
+```
+
+```
+## Frequency of column OncotreeLineage
+## Lung                         241
+## Lymphoid                     209
+## CNS/Brain                    123
+## Skin                         118
+## Esophagus/Stomach             95
+## Breast                        92
+## Bowel                         87
+## Head and Neck                 81
+## Myeloid                       77
+## Bone                          75
+## Ovary/Fallopian Tube          74
+## Pancreas                      65
+## Kidney                        64
+## Peripheral Nervous System     55
+## Soft Tissue                   54
+## Uterus                        41
+## Fibroblast                    41
+## Biliary Tract                 40
+## Bladder/Urinary Tract         39
+## Normal                        39
+## Pleura                        35
+## Liver                         28
+## Cervix                        25
+## Eye                           19
+## Thyroid                       18
+## Prostate                      14
+## Vulva/Vagina                   5
+## Ampulla of Vater               4
+## Testis                         4
+## Adrenal Gland                  1
+## Other                          1
+## Name: count, dtype: int64
+```
+
+Notice that the output of some of these methods are Float (NumPy). This refers to a Python Object called NumPy that is extremely popular for scientific computing, but we're not focused on that in this course.)
+
+## Simple data visualization
+
+We will dedicate extensive time later this course to talk about data visualization, but the Dataframe's column, Series, has a method called [`.plot()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.plot.html) that can help us make simple plots for one variable. The `.plot()` method will by default make a line plot, but it is not necessary the plot style we want, so we can give the optional argument `kind` a String value to specify the plot style. We use it for making a histogram or bar plot.
+
+| Plot style | Useful for | kind = | Code                                                         |
+|-------------|-------------|-------------|---------------------------------|
+| Histogram  | Numerics   | "hist" | `metadata.Age.plot(kind = "hist")`                           |
+| Bar plot   | Strings    | "bar"  | `metadata.OncotreeSubtype.value_counts().plot(kind = "bar")` |
+
+Let's look at a histogram:
+
+
+``` python
+import matplotlib.pyplot as plt
+
+plt.figure()
+metadata.Age.plot(kind = "hist")
+plt.show()
+```
+
+![](resources/images/03-data-wrangling1_files/figure-docx/unnamed-chunk-11-1.png)<!-- -->
+
+Let's look at a bar plot:
+
+
+``` python
+plt.figure()
+metadata.OncotreeLineage.value_counts().plot(kind = "bar")
+plt.show()
+```
+
+![](resources/images/03-data-wrangling1_files/figure-docx/unnamed-chunk-12-3.png)<!-- -->
+
+(The `plt.figure()` and `plt.show()` functions are used to render the plots on the website, but you don't need to use it for your exercises. We will discuss this in more detail during our week of data visualization.)
+
+#### Chained function calls
+
+Let's look at our bar plot syntax more carefully. We start with the column `metadata.OncotreeLineage`, and then we first use the method `.value_counts()` to get a *Series* of a frequency table. Then, we take the frequency table Series and use the `.plot()` method.
+
+It is quite common in Python to have multiple "chained" function calls, in which the output of `.value_counts()` is used for the input of `.plot()` all in one line of code. It takes a bit of time to get used to this!
+
+Here's another example of a chained function call, which looks quite complex, but let's break it down:
+
+
+``` python
+plt.figure()
+
+metadata.loc[metadata.AgeCategory == "Adult", ].OncotreeLineage.value_counts().plot(kind="bar")
+
+plt.show()
+```
+
+![](resources/images/03-data-wrangling1_files/figure-docx/unnamed-chunk-13-5.png)<!-- -->
+
+1.  We first take the entire `metadata` and do some subsetting, which outputs a Dataframe.
+2.  We access the `OncotreeLineage` column, which outputs a Series.
+3.  We use the method `.value_counts()`, which outputs a Series.
+4.  We make a plot out of it!
+
+We could have, alternatively, done this in several lines of code:
+
+
+``` python
+plt.figure()
+
+metadata_subset = metadata.loc[metadata.AgeCategory == "Adult", ]
+metadata_subset_lineage = metadata_subset.OncotreeLineage
+lineage_freq = metadata_subset_lineage.value_counts()
+lineage_freq.plot(kind = "bar")
+
+plt.show()
+```
+
+![](resources/images/03-data-wrangling1_files/figure-docx/unnamed-chunk-14-7.png)<!-- -->
+
+These are two different *styles* of code, but they do the exact same thing. It's up to you to decide what is easier for you to understand.
+
+## Exercises
+
+Exercise for week 3 can be found [here](https://colab.research.google.com/drive/1ClNOJviyrcaaoVq5F-YtsO7NhMqn315c?usp=sharing).
diff --git a/docs/04-data-wrangling2.md b/docs/04-data-wrangling2.md
new file mode 100644
index 0000000..77cb01c
--- /dev/null
+++ b/docs/04-data-wrangling2.md
@@ -0,0 +1,334 @@
+
+
+# Data Wrangling, Part 2
+
+We will continue to learn about data analysis with Dataframes. Let's load our three Dataframes from the Depmap project in again:
+
+
+``` python
+import pandas as pd
+import numpy as np
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+mutation = pd.read_csv("classroom_data/mutation.csv")
+expression = pd.read_csv("classroom_data/expression.csv")
+```
+
+## Creating new columns
+
+Often, we want to perform some kind of transformation on our data's columns: perhaps you want to add the values of columns together, or perhaps you want to represent your column in a different scale.
+
+To create a new column, you simply modify it as if it exists using the bracket operation `[ ]`, and the column will be created:
+
+
+``` python
+metadata['AgePlusTen'] = metadata['Age'] + 10
+expression['KRAS_NRAS_exp'] = expression['KRAS_Exp'] + expression['NRAS_Exp']
+expression['log_PIK3CA_Exp'] = np.log(expression['PIK3CA_Exp'])
+```
+
+where [`np.log(x)`](https://numpy.org/doc/stable/reference/generated/numpy.log.html) is a function imported from the module NumPy that takes in a numeric and returns the log-transformed value.
+
+Note: you cannot create a new column referring to the attribute of the Dataframe, such as: `expression.KRAS_Exp_log = np.log(expression.KRAS_Exp)`.
+
+## Merging two Dataframes together
+
+Suppose we have the following Dataframes:
+
+`expression`
+
+| ModelID      | PIK3CA_Exp | log_PIK3CA_Exp |
+|--------------|------------|----------------|
+| "ACH-001113" | 5.138733   | 1.636806       |
+| "ACH-001289" | 3.184280   | 1.158226       |
+| "ACH-001339" | 3.165108   | 1.152187       |
+
+`metadata`
+
+| ModelID      | OncotreeLineage | Age |
+|--------------|-----------------|-----|
+| "ACH-001113" | "Lung"          | 69  |
+| "ACH-001289" | "CNS/Brain"     | NaN |
+| "ACH-001339" | "Skin"          | 14  |
+
+Suppose that I want to compare the relationship between `OncotreeLineage` and `PIK3CA_Exp`, but they are columns in different Dataframes. We want a new Dataframe that looks like this:
+
+| ModelID      | PIK3CA_Exp | log_PIK3CA_Exp | OncotreeLineage | Age |
+|--------------|------------|----------------|-----------------|-----|
+| "ACH-001113" | 5.138733   | 1.636806       | "Lung"          | 69  |
+| "ACH-001289" | 3.184280   | 1.158226       | "CNS/Brain"     | NaN |
+| "ACH-001339" | 3.165108   | 1.152187       | "Skin"          | 14  |
+
+We see that in both dataframes,
+
+-   the rows (observations) represent cell lines.
+
+-   there is a common column `ModelID`, with shared values between the two dataframes that can faciltate the merging process. We call this an **index**.
+
+We will use the method [`.merge()`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html) for Dataframes. It takes a Dataframe to merge with as the required input argument. The method looks for a common index column between the two dataframes and merge based on that index.
+
+
+``` python
+merged = metadata.merge(expression)
+```
+
+It's usually better to specify what that index column to avoid ambiguity, using the `on` optional argument:
+
+
+``` python
+merged = metadata.merge(expression, on='ModelID')
+```
+
+If the index column for the two Dataframes are named differently, you can specify the column name for each Dataframe:
+
+
+``` python
+merged = metadata.merge(expression, left_on='ModelID', right_on='ModelID')
+```
+
+One of the most import checks you should do when merging dataframes is to look at the number of rows and columns before and after merging to see whether it makes sense or not:
+
+The number of rows and columns of `metadata`:
+
+
+``` python
+metadata.shape
+```
+
+```
+## (1864, 31)
+```
+
+The number of rows and columns of `expression`:
+
+
+``` python
+expression.shape
+```
+
+```
+## (1450, 538)
+```
+
+The number of rows and columns of `merged`:
+
+
+``` python
+merged.shape
+```
+
+```
+## (1450, 568)
+```
+
+We see that the number of *columns* in `merged` combines the number of columns in `metadata` and `expression`, while the number of *rows* in `merged` is the smaller of the number of rows in `metadata` and `expression`: it only keeps rows that are found in both Dataframe's index columns. This kind of join is called "inner join", because in the Venn Diagram of elements common in both index column, we keep the inner overlap:
+
+![](images/join.png)
+
+You can specifiy the join style by changing the optional input argument `how`.
+
+-   `how = "outer"` keeps all observations - also known as a "full join"
+
+-   `how = "left"` keeps all observations in the left Dataframe.
+
+-   `how = "right"` keeps all observations in the right Dataframe.
+
+-   `how = "inner"` keeps observations common to both Dataframe. This is the default value of `how`.
+
+## Grouping and summarizing Dataframes
+
+In a dataset, there may be groups of observations that we want to understand, such as case vs. control, or comparing different cancer subtypes. For example, in `metadata`, the observation is cell lines, and perhaps we want to group cell lines into their respective cancer type, `OncotreeLineage`, and look at the mean age for each cancer type.
+
+We want to take `metadata`:
+
+| ModelID      | OncotreeLineage | Age |
+|--------------|-----------------|-----|
+| "ACH-001113" | "Lung"          | 69  |
+| "ACH-001289" | "Lung"          | 23  |
+| "ACH-001339" | "Skin"          | 14  |
+| "ACH-002342" | "Brain"         | 23  |
+| "ACH-004854" | "Brain"         | 56  |
+| "ACH-002921" | "Brain"         | 67  |
+
+into:
+
+| OncotreeLineage | MeanAge |
+|-----------------|---------|
+| "Lung"          | 46      |
+| "Skin"          | 14      |
+| "Brain"         | 48.67   |
+
+To get there, we need to:
+
+-   **Group** the data based on some criteria, elements of `OncotreeLineage`
+
+-   **Summarize** each group via a summary statistic performed on a column, such as `Age`.
+
+We first subset the the two columns we need, and then use the methods [`.group_by(x)`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html) and `.mean()`.
+
+
+``` python
+metadata_grouped = metadata.groupby("OncotreeLineage")
+metadata_grouped['Age'].mean()
+```
+
+```
+## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64
+```
+
+Here's what's going on:
+
+-   We use the Dataframe method [`.group_by(x)`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html) and specify the column we want to group by. The output of this method is a Grouped Dataframe object. It still contains all the information of the `metadata` Dataframe, but it makes a note that it's been grouped.
+
+-   We subset to the column `Age`. The grouping information still persists (This is a Grouped Series object).
+
+-   We use the method `.mean()` to calculate the mean value of `Age` within each group defined by `OncotreeLineage`.
+
+Alternatively, this could have been done in a chain of methods:
+
+
+``` python
+metadata.groupby("OncotreeLineage")["Age"].mean()
+```
+
+```
+## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64
+```
+
+Once a Dataframe has been grouped and a column is selected, all the summary statistics methods you learned from last week, such as `.mean()`, `.median()`, `.max()`, can be used. One new summary statistics method that is useful for this grouping and summarizing analysis is [`.count()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.count.html) which tells you how many entries are counted within each group.
+
+### Optional: Multiple grouping, Multiple columns, Multiple summary statistics
+
+Sometimes, when performing grouping and summary analysis, you want to operate on multiple columns simultaneously.
+
+For example, you may want to group by a combination of `OncotreeLineage` and `AgeCategory`, such as "Lung" and "Adult" as one grouping. You can do so like this:
+
+
+``` python
+metadata_grouped = metadata.groupby(["OncotreeLineage", "AgeCategory"])
+metadata_grouped['Age'].mean()
+```
+
+```
+## OncotreeLineage   AgeCategory
+## Adrenal Gland     Adult          55.000000
+## Ampulla of Vater  Adult          65.500000
+##                   Unknown              NaN
+## Biliary Tract     Adult          58.450000
+##                   Unknown              NaN
+##                                    ...    
+## Thyroid           Unknown              NaN
+## Uterus            Adult          62.060606
+##                   Fetus                NaN
+##                   Unknown              NaN
+## Vulva/Vagina      Adult          75.400000
+## Name: Age, Length: 72, dtype: float64
+```
+
+You can also summarize on multiple columns simultaneously. For each column, you have to specify what summary statistic functions you want to use. This can be specified via the [`.agg(x)`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.agg.html) method on a Grouped Dataframe.
+
+For example, coming back to our age case-control Dataframe,
+
+
+``` python
+df = pd.DataFrame(data={'status': ["treated", "untreated", "untreated", "discharged", "treated"],
+                            'age_case': [25, 43, 21, 65, 7],
+                            'age_control': [49, 20, 32, 25, 32]})
+                            
+df
+```
+
+```
+##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32
+```
+
+We group by `status` and summarize `age_case` and `age_control` with a few summary statistics each:
+
+
+``` python
+df.groupby("status").agg({"age_case": "mean", "age_control": ["min", "max", "mean"]})
+```
+
+```
+##            age_case age_control          
+##                mean         min max  mean
+## status                                   
+## discharged     65.0          25  25  25.0
+## treated        16.0          32  49  40.5
+## untreated      32.0          20  32  26.0
+```
+
+The input argument to the `.agg(x)` method is called a [Dictionary](https://docs.python.org/3/tutorial/datastructures.html#dictionaries), which let's you structure information in a paired relationship. You can learn more about dictionaries here.
+
+## Exercises
+
+Exercise for week 4 can be found [here](https://colab.research.google.com/drive/1ntkUdKQ209vu1M89rcsBst-pKKuwzdwX?usp=sharing).
diff --git a/docs/05-data-visualization.md b/docs/05-data-visualization.md
new file mode 100644
index 0000000..a48df0f
--- /dev/null
+++ b/docs/05-data-visualization.md
@@ -0,0 +1,226 @@
+
+
+# Data Visualization
+
+In our final to last week together, we learn about how to visualize our data.
+
+There are several different data visualization modules in Python:
+
+-   [matplotlib](https://matplotlib.org/) is a general purpose plotting module that is commonly used.
+
+-   [seaborn](https://seaborn.pydata.org/) is a plotting module built on top of matplotlib focused on data science and statistical visualization. We will focus on this module for this course.
+
+-   [plotnine](https://plotnine.org/) is a plotting module based on the grammar of graphics organization of making plots. This is very similar to the R package "ggplot".
+
+To get started, we will consider these most simple and common plots:
+
+Distributions (one variable)
+
+-   Histograms
+
+Relational (between 2 continuous variables)
+
+-   Scatterplots
+
+-   Line plots
+
+Categorical (between 1 categorical and 1 continuous variable)
+
+-   Bar plots
+
+-   Violin plots
+
+[![Image source: Seaborn's overview of plotting functions](https://seaborn.pydata.org/_images/function_overview_8_0.png)](https://seaborn.pydata.org/tutorial/function_overview.html)
+
+Why do we focus on these common plots? Our eyes are better at distinguishing certain visual features more than others. All of these plots are focused on their position to depict data, which gives us the most effective visual scale.
+
+[![Image Source: Visualization Analysis and Design by [Tamara Munzner](https://www.oreilly.com/search?q=author:%22Tamara%20Munzner%22)](https://www.oreilly.com/api/v2/epubs/9781466508910/files/image/fig5-1.png)](https://www.oreilly.com/library/view/visualization-analysis-and/9781466508910/K14708_C005.xhtml)
+
+Let's load in our genomics datasets and start making some plots from them.
+
+
+``` python
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+mutation = pd.read_csv("classroom_data/mutation.csv")
+expression = pd.read_csv("classroom_data/expression.csv")
+```
+
+## Distributions (one variable)
+
+To create a histogram, we use the function [`sns.displot()`](https://seaborn.pydata.org/generated/seaborn.displot.html) and we specify the input argument `data` as our dataframe, and the input argument `x` as the column name in a String.
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-3-1.png)<!-- -->
+
+(For the webpage's purpose, assign the plot to a variable `plot`. In practice, you don't need to do that. You can just write `sns.displot(data=metadata, x="Age")`).
+
+A common parameter to consider when making histogram is how big the bins are. You can specify the bin width via `binwidth` argument, or the number of bins via `bins` argument.
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", binwidth = 10)
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-4-3.png)<!-- -->
+
+Our histogram also works for categorical variables, such as "Sex".
+
+
+``` python
+plot = sns.displot(data=metadata, x="Sex")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-5-5.png)<!-- -->
+
+**Conditioning on other variables**
+
+Sometimes, you want to examine a distribution, such as Age, conditional on other variables, such as Age for Female, Age for Male, and Age for Unknown: what is the distribution of age when compared with sex? There are several ways of doing it. First, you could color variables by color, using the `hue` input argument:
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", hue="Sex")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-6-7.png)<!-- -->
+
+It is rather hard to tell the groups apart from the coloring. So, we add a new option that we want to separate each bar category via `multiple="dodge"` input argument:
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", hue="Sex", multiple="dodge")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-7-9.png)<!-- -->
+
+Lastly, an alternative to using colors to display the conditional variable, we could make a subplot for each conditional variable's value via `col="Sex"` or `row="Sex"`:
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", col="Sex")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-8-11.png)<!-- -->
+
+You can find a lot more details about distributions and histograms in [the Seaborn tutorial](https://seaborn.pydata.org/tutorial/distributions.html).
+
+## Relational (between 2 continuous variables)
+
+To visualize two continuous variables, it is common to use a scatterplot or a lineplot. We use the function [`sns.relplot()`](https://seaborn.pydata.org/generated/seaborn.relplot.html) and we specify the input argument `data` as our dataframe, and the input arguments `x` and `y` as the column names in a String:
+
+
+``` python
+plot = sns.relplot(data=expression, x="KRAS_Exp", y="EGFR_Exp")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-9-13.png)<!-- -->
+
+To conditional on other variables, plotting features are used to distinguish conditional variable values:
+
+-   `hue` (similar to the histogram)
+
+-   `style`
+
+-   `size`
+
+Let's merge `expression` and `metadata` together, so that we can examine KRAS and EGFR relationships conditional on primary vs. metastatic cancer status. Here is the scatterplot with different color:
+
+
+``` python
+expression_metadata = expression.merge(metadata)
+
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", hue="PrimaryOrMetastasis")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-10-15.png)<!-- -->
+
+Here is the scatterplot with different shapes:
+
+
+``` python
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", style="PrimaryOrMetastasis")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-11-17.png)<!-- -->
+
+You can also try plotting with `size=PrimaryOrMetastasis"` if you like. None of these seem pretty effective at distinguishing the two groups, so we will try subplot faceting as we did for the histogram:
+
+
+``` python
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", col="PrimaryOrMetastasis")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-12-19.png)<!-- -->
+
+You can also conditional on multiple variables by assigning a different variable to the conditioning options:
+
+
+``` python
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", hue="PrimaryOrMetastasis", col="AgeCategory")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-13-21.png)<!-- -->
+
+You can find a lot more details about relational plots such as scatterplots and lineplots [in the Seaborn tutorial](https://seaborn.pydata.org/tutorial/relational.html).
+
+## Categorical (between 1 categorical and 1 continuous variable)
+
+A very similar pattern follows for categorical plots. We start with [sns.catplot()](https://seaborn.pydata.org/generated/seaborn.catplot.html) as our main plotting function, with the basic input arguments:
+
+-   `data`
+
+-   `x`
+
+-   `y`
+
+You can change the plot styles via the input arguments:
+
+-   `kind`: "strip", "box", "swarm", etc.
+
+You can add additional conditional variables via the input arguments:
+
+-   `hue`
+
+-   `col`
+
+-   `row`
+
+See categorical plots [in the Seaborn tutorial.](https://seaborn.pydata.org/tutorial/categorical.html)
+
+## Basic plot customization
+
+You can easily change the axis labels and title if you modify the plot object, using the method `.set()`:
+
+
+``` python
+exp_plot = sns.relplot(data=expression, x="KRAS_Exp", y="EGFR_Exp")
+exp_plot.set(xlabel="KRAS Espression", ylabel="EGFR Expression", title="Gene expression relationship")
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-14-23.png)<!-- -->![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-14-24.png)<!-- -->
+
+You can change the color palette by setting adding the `palette` input argument to any of the plots. You can explore available color palettes [here](https://www.practicalpythonfordatascience.com/ap_seaborn_palette):
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", hue="Sex", multiple="dodge", palette=sns.color_palette(palette='rainbow')
+)
+```
+
+```
+## <string>:1: UserWarning: The palette list has more values (6) than needed (3), which may not be intended.
+```
+
+![](resources/images/05-data-visualization_files/figure-docx/unnamed-chunk-15-27.png)<!-- -->
+
+## Exercises
+
+Exercise for week 5 can be found [here](https://colab.research.google.com/drive/1kT3zzq2rrhL1vHl01IdW5L1V7v0iK0wY?usp=sharing).
diff --git a/docs/404.html b/docs/404.html
index 2c73718..ac6d572 100644
--- a/docs/404.html
+++ b/docs/404.html
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
diff --git a/docs/About.md b/docs/About.md
index 121b3d7..6c7533a 100644
--- a/docs/About.md
+++ b/docs/About.md
@@ -51,7 +51,7 @@ These credits are based on our [course contributors table guidelines](https://ww
 ##  collate  en_US.UTF-8
 ##  ctype    en_US.UTF-8
 ##  tz       Etc/UTC
-##  date     2024-08-07
+##  date     2024-09-26
 ##  pandoc   3.1.1 @ /usr/local/bin/ (via rmarkdown)
 ## 
 ## ─ Packages ───────────────────────────────────────────────────────────────────
diff --git a/docs/Introduction-to-Python.docx b/docs/Introduction-to-Python.docx
index 8560319..ced8ff2 100644
Binary files a/docs/Introduction-to-Python.docx and b/docs/Introduction-to-Python.docx differ
diff --git a/docs/about-the-authors.html b/docs/about-the-authors.html
index 2a814fd..b05d8fa 100644
--- a/docs/about-the-authors.html
+++ b/docs/about-the-authors.html
@@ -28,7 +28,7 @@
   <meta name="apple-mobile-web-app-status-bar-style" content="black" />
   
   <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
-<link rel="prev" href="intro-to-computing.html"/>
+<link rel="prev" href="data-visualization.html"/>
 <link rel="next" href="references.html"/>
 <script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -342,7 +386,7 @@ <h1>About the Authors<a href="about-the-authors.html#about-the-authors" class="a
 ##  collate  en_US.UTF-8
 ##  ctype    en_US.UTF-8
 ##  tz       Etc/UTC
-##  date     2024-08-07
+##  date     2024-09-26
 ##  pandoc   3.1.1 @ /usr/local/bin/ (via rmarkdown)
 ## 
 ## ─ Packages ───────────────────────────────────────────────────────────────────
@@ -422,7 +466,7 @@ <h1>About the Authors<a href="about-the-authors.html#about-the-authors" class="a
           </div>
         </div>
       </div>
-<a href="intro-to-computing.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-visualization.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
 <a href="references.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
     </div>
   </div>
diff --git a/docs/data-visualization.html b/docs/data-visualization.html
new file mode 100644
index 0000000..671f810
--- /dev/null
+++ b/docs/data-visualization.html
@@ -0,0 +1,443 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 5 Data Visualization | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 5 Data Visualization | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 5 Data Visualization | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="data-wrangling-part-2.html"/>
+<link rel="next" href="about-the-authors.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="data-visualization" class="section level1 hasAnchor" number="5">
+<h1><span class="header-section-number">Chapter 5</span> Data Visualization<a href="data-visualization.html#data-visualization" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>In our final to last week together, we learn about how to visualize our data.</p>
+<p>There are several different data visualization modules in Python:</p>
+<ul>
+<li><p><a href="https://matplotlib.org/">matplotlib</a> is a general purpose plotting module that is commonly used.</p></li>
+<li><p><a href="https://seaborn.pydata.org/">seaborn</a> is a plotting module built on top of matplotlib focused on data science and statistical visualization. We will focus on this module for this course.</p></li>
+<li><p><a href="https://plotnine.org/">plotnine</a> is a plotting module based on the grammar of graphics organization of making plots. This is very similar to the R package “ggplot”.</p></li>
+</ul>
+<p>To get started, we will consider these most simple and common plots:</p>
+<p>Distributions (one variable)</p>
+<ul>
+<li>Histograms</li>
+</ul>
+<p>Relational (between 2 continuous variables)</p>
+<ul>
+<li><p>Scatterplots</p></li>
+<li><p>Line plots</p></li>
+</ul>
+<p>Categorical (between 1 categorical and 1 continuous variable)</p>
+<ul>
+<li><p>Bar plots</p></li>
+<li><p>Violin plots</p></li>
+</ul>
+<p><a href="https://seaborn.pydata.org/tutorial/function_overview.html"><img src="https://seaborn.pydata.org/_images/function_overview_8_0.png" alt="Image source: Seaborn’s overview of plotting functions" /></a></p>
+<p>Why do we focus on these common plots? Our eyes are better at distinguishing certain visual features more than others. All of these plots are focused on their position to depict data, which gives us the most effective visual scale.</p>
+<p><a href="https://www.oreilly.com/library/view/visualization-analysis-and/9781466508910/K14708_C005.xhtml"><img src="https://www.oreilly.com/api/v2/epubs/9781466508910/files/image/fig5-1.png" alt="Image Source: Visualization Analysis and Design by [Tamara Munzner](https://www.oreilly.com/search?q=author:%22Tamara%20Munzner%22)" /></a></p>
+<p>Let’s load in our genomics datasets and start making some plots from them.</p>
+<div class="sourceCode" id="cb113"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb113-1"><a href="data-visualization.html#cb113-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb113-2"><a href="data-visualization.html#cb113-2" tabindex="-1"></a><span class="im">import</span> seaborn <span class="im">as</span> sns</span>
+<span id="cb113-3"><a href="data-visualization.html#cb113-3" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
+<span id="cb113-4"><a href="data-visualization.html#cb113-4" tabindex="-1"></a></span>
+<span id="cb113-5"><a href="data-visualization.html#cb113-5" tabindex="-1"></a></span>
+<span id="cb113-6"><a href="data-visualization.html#cb113-6" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb113-7"><a href="data-visualization.html#cb113-7" tabindex="-1"></a>mutation <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/mutation.csv&quot;</span>)</span>
+<span id="cb113-8"><a href="data-visualization.html#cb113-8" tabindex="-1"></a>expression <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/expression.csv&quot;</span>)</span></code></pre></div>
+<div id="distributions-one-variable" class="section level2 hasAnchor" number="5.1">
+<h2><span class="header-section-number">5.1</span> Distributions (one variable)<a href="data-visualization.html#distributions-one-variable" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>To create a histogram, we use the function <a href="https://seaborn.pydata.org/generated/seaborn.displot.html"><code>sns.displot()</code></a> and we specify the input argument <code>data</code> as our dataframe, and the input argument <code>x</code> as the column name in a String.</p>
+<div class="sourceCode" id="cb114"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb114-1"><a href="data-visualization.html#cb114-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png" width="480" /></p>
+<p>(For the webpage’s purpose, assign the plot to a variable <code>plot</code>. In practice, you don’t need to do that. You can just write <code>sns.displot(data=metadata, x="Age")</code>).</p>
+<p>A common parameter to consider when making histogram is how big the bins are. You can specify the bin width via <code>binwidth</code> argument, or the number of bins via <code>bins</code> argument.</p>
+<div class="sourceCode" id="cb115"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb115-1"><a href="data-visualization.html#cb115-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, binwidth <span class="op">=</span> <span class="dv">10</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png" width="480" /></p>
+<p>Our histogram also works for categorical variables, such as “Sex”.</p>
+<div class="sourceCode" id="cb116"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb116-1"><a href="data-visualization.html#cb116-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Sex&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png" width="480" /></p>
+<p><strong>Conditioning on other variables</strong></p>
+<p>Sometimes, you want to examine a distribution, such as Age, conditional on other variables, such as Age for Female, Age for Male, and Age for Unknown: what is the distribution of age when compared with sex? There are several ways of doing it. First, you could color variables by color, using the <code>hue</code> input argument:</p>
+<div class="sourceCode" id="cb117"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb117-1"><a href="data-visualization.html#cb117-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, hue<span class="op">=</span><span class="st">&quot;Sex&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png" width="590" /></p>
+<p>It is rather hard to tell the groups apart from the coloring. So, we add a new option that we want to separate each bar category via <code>multiple="dodge"</code> input argument:</p>
+<div class="sourceCode" id="cb118"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb118-1"><a href="data-visualization.html#cb118-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, hue<span class="op">=</span><span class="st">&quot;Sex&quot;</span>, multiple<span class="op">=</span><span class="st">&quot;dodge&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png" width="590" /></p>
+<p>Lastly, an alternative to using colors to display the conditional variable, we could make a subplot for each conditional variable’s value via <code>col="Sex"</code> or <code>row="Sex"</code>:</p>
+<div class="sourceCode" id="cb119"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb119-1"><a href="data-visualization.html#cb119-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, col<span class="op">=</span><span class="st">&quot;Sex&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png" width="1440" /></p>
+<p>You can find a lot more details about distributions and histograms in <a href="https://seaborn.pydata.org/tutorial/distributions.html">the Seaborn tutorial</a>.</p>
+</div>
+<div id="relational-between-2-continuous-variables" class="section level2 hasAnchor" number="5.2">
+<h2><span class="header-section-number">5.2</span> Relational (between 2 continuous variables)<a href="data-visualization.html#relational-between-2-continuous-variables" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>To visualize two continuous variables, it is common to use a scatterplot or a lineplot. We use the function <a href="https://seaborn.pydata.org/generated/seaborn.relplot.html"><code>sns.relplot()</code></a> and we specify the input argument <code>data</code> as our dataframe, and the input arguments <code>x</code> and <code>y</code> as the column names in a String:</p>
+<div class="sourceCode" id="cb120"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb120-1"><a href="data-visualization.html#cb120-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png" width="480" /></p>
+<p>To conditional on other variables, plotting features are used to distinguish conditional variable values:</p>
+<ul>
+<li><p><code>hue</code> (similar to the histogram)</p></li>
+<li><p><code>style</code></p></li>
+<li><p><code>size</code></p></li>
+</ul>
+<p>Let’s merge <code>expression</code> and <code>metadata</code> together, so that we can examine KRAS and EGFR relationships conditional on primary vs. metastatic cancer status. Here is the scatterplot with different color:</p>
+<div class="sourceCode" id="cb121"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb121-1"><a href="data-visualization.html#cb121-1" tabindex="-1"></a>expression_metadata <span class="op">=</span> expression.merge(metadata)</span>
+<span id="cb121-2"><a href="data-visualization.html#cb121-2" tabindex="-1"></a></span>
+<span id="cb121-3"><a href="data-visualization.html#cb121-3" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, hue<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png" width="629" /></p>
+<p>Here is the scatterplot with different shapes:</p>
+<div class="sourceCode" id="cb122"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb122-1"><a href="data-visualization.html#cb122-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, style<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png" width="629" /></p>
+<p>You can also try plotting with <code>size=PrimaryOrMetastasis"</code> if you like. None of these seem pretty effective at distinguishing the two groups, so we will try subplot faceting as we did for the histogram:</p>
+<div class="sourceCode" id="cb123"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb123-1"><a href="data-visualization.html#cb123-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, col<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png" width="1440" /></p>
+<p>You can also conditional on multiple variables by assigning a different variable to the conditioning options:</p>
+<div class="sourceCode" id="cb124"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb124-1"><a href="data-visualization.html#cb124-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, hue<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>, col<span class="op">=</span><span class="st">&quot;AgeCategory&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png" width="2069" /></p>
+<p>You can find a lot more details about relational plots such as scatterplots and lineplots <a href="https://seaborn.pydata.org/tutorial/relational.html">in the Seaborn tutorial</a>.</p>
+</div>
+<div id="categorical-between-1-categorical-and-1-continuous-variable" class="section level2 hasAnchor" number="5.3">
+<h2><span class="header-section-number">5.3</span> Categorical (between 1 categorical and 1 continuous variable)<a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>A very similar pattern follows for categorical plots. We start with <a href="https://seaborn.pydata.org/generated/seaborn.catplot.html">sns.catplot()</a> as our main plotting function, with the basic input arguments:</p>
+<ul>
+<li><p><code>data</code></p></li>
+<li><p><code>x</code></p></li>
+<li><p><code>y</code></p></li>
+</ul>
+<p>You can change the plot styles via the input arguments:</p>
+<ul>
+<li><code>kind</code>: “strip”, “box”, “swarm”, etc.</li>
+</ul>
+<p>You can add additional conditional variables via the input arguments:</p>
+<ul>
+<li><p><code>hue</code></p></li>
+<li><p><code>col</code></p></li>
+<li><p><code>row</code></p></li>
+</ul>
+<p>See categorical plots <a href="https://seaborn.pydata.org/tutorial/categorical.html">in the Seaborn tutorial.</a></p>
+</div>
+<div id="basic-plot-customization" class="section level2 hasAnchor" number="5.4">
+<h2><span class="header-section-number">5.4</span> Basic plot customization<a href="data-visualization.html#basic-plot-customization" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>You can easily change the axis labels and title if you modify the plot object, using the method <code>.set()</code>:</p>
+<div class="sourceCode" id="cb125"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb125-1"><a href="data-visualization.html#cb125-1" tabindex="-1"></a>exp_plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>)</span>
+<span id="cb125-2"><a href="data-visualization.html#cb125-2" tabindex="-1"></a>exp_plot.<span class="bu">set</span>(xlabel<span class="op">=</span><span class="st">&quot;KRAS Espression&quot;</span>, ylabel<span class="op">=</span><span class="st">&quot;EGFR Expression&quot;</span>, title<span class="op">=</span><span class="st">&quot;Gene expression relationship&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png" width="244" /><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png" width="480" /></p>
+<p>You can change the color palette by setting adding the <code>palette</code> input argument to any of the plots. You can explore available color palettes <a href="https://www.practicalpythonfordatascience.com/ap_seaborn_palette">here</a>:</p>
+<div class="sourceCode" id="cb126"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb126-1"><a href="data-visualization.html#cb126-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, hue<span class="op">=</span><span class="st">&quot;Sex&quot;</span>, multiple<span class="op">=</span><span class="st">&quot;dodge&quot;</span>, palette<span class="op">=</span>sns.color_palette(palette<span class="op">=</span><span class="st">&#39;rainbow&#39;</span>)</span>
+<span id="cb126-2"><a href="data-visualization.html#cb126-2" tabindex="-1"></a>)</span></code></pre></div>
+<pre><code>## &lt;string&gt;:1: UserWarning: The palette list has more values (6) than needed (3), which may not be intended.</code></pre>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png" width="590" /></p>
+</div>
+<div id="exercises-4" class="section level2 hasAnchor" number="5.5">
+<h2><span class="header-section-number">5.5</span> Exercises<a href="data-visualization.html#exercises-4" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 5 can be found <a href="https://colab.research.google.com/drive/1kT3zzq2rrhL1vHl01IdW5L1V7v0iK0wY?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="data-wrangling-part-2.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="about-the-authors.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/data-wrangling-part-1.html b/docs/data-wrangling-part-1.html
new file mode 100644
index 0000000..0ece4cc
--- /dev/null
+++ b/docs/data-wrangling-part-1.html
@@ -0,0 +1,655 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 3 Data Wrangling, Part 1 | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 3 Data Wrangling, Part 1 | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 3 Data Wrangling, Part 1 | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="working-with-data-structures.html"/>
+<link rel="next" href="data-wrangling-part-2.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="data-wrangling-part-1" class="section level1 hasAnchor" number="3">
+<h1><span class="header-section-number">Chapter 3</span> Data Wrangling, Part 1<a href="data-wrangling-part-1.html#data-wrangling-part-1" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>From our first two lessons, we are now equipped with enough fundamental programming skills to apply it to various steps in the data science workflow, which is a natural cycle that occurs in data analysis.</p>
+<div class="float">
+<img src="https://d33wubrfki0l68.cloudfront.net/571b056757d68e6df81a3e3853f54d3c76ad6efc/32d37/diagrams/data-science.png" width="550" alt="Data science workflow. Image source: R for Data Science." />
+<div class="figcaption">Data science workflow. Image source: R for Data Science.</div>
+</div>
+<p>For the rest of the course, we focus on <em>Transform</em> and <em>Visualize</em> with the assumption that our data is in a nice, “Tidy format”. First, we need to understand what it means for a data to be “Tidy”.</p>
+<div id="tidy-data" class="section level2 hasAnchor" number="3.1">
+<h2><span class="header-section-number">3.1</span> Tidy Data<a href="data-wrangling-part-1.html#tidy-data" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Here, we describe a standard of organizing data. It is important to have standards, as it facilitates a consistent way of thinking about data organization and building tools (functions) that make use of that standard. The principles of <strong>tidy data</strong>, developed by Hadley Wickham:</p>
+<ol style="list-style-type: decimal">
+<li><p>Each variable must have its own column.</p></li>
+<li><p>Each observation must have its own row.</p></li>
+<li><p>Each value must have its own cell.</p></li>
+</ol>
+<p>If you want to be technical about what variables and observations are, Hadley Wickham describes:</p>
+<blockquote>
+<p>A <strong>variable</strong> contains all values that measure the same underlying attribute (like height, temperature, duration) across units. An <strong>observation</strong> contains all values measured on the same unit (like a person, or a day, or a race) across attributes.</p>
+</blockquote>
+<div class="float">
+<img src="https://r4ds.hadley.nz/images/tidy-1.png" width="800" alt="A tidy dataframe. Image source: R for Data Science." />
+<div class="figcaption">A tidy dataframe. Image source: R for Data Science.</div>
+</div>
+</div>
+<div id="our-working-tidy-data-depmap-project" class="section level2 hasAnchor" number="3.2">
+<h2><span class="header-section-number">3.2</span> Our working Tidy Data: DepMap Project<a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>The <a href="https://depmap.org/portal/">Dependency Map project</a> is a multi-omics profiling of cancer cell lines combined with functional assays such as CRISPR and drug sensitivity to help identify cancer vulnerabilities and drug targets. Here are some of the data that we have public access to. We have been looking at the metadata since last session.</p>
+<ul>
+<li><p>Metadata</p></li>
+<li><p>Somatic mutations</p></li>
+<li><p>Gene expression</p></li>
+<li><p>Drug sensitivity</p></li>
+<li><p>CRISPR knockout</p></li>
+<li><p>and more…</p></li>
+</ul>
+<p>Let’s load these datasets in, and see how these datasets fit the definition of Tidy data:</p>
+<div class="sourceCode" id="cb69"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb69-1"><a href="data-wrangling-part-1.html#cb69-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb69-2"><a href="data-wrangling-part-1.html#cb69-2" tabindex="-1"></a></span>
+<span id="cb69-3"><a href="data-wrangling-part-1.html#cb69-3" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb69-4"><a href="data-wrangling-part-1.html#cb69-4" tabindex="-1"></a>mutation <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/mutation.csv&quot;</span>)</span>
+<span id="cb69-5"><a href="data-wrangling-part-1.html#cb69-5" tabindex="-1"></a>expression <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/expression.csv&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb70"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb70-1"><a href="data-wrangling-part-1.html#cb70-1" tabindex="-1"></a>metadata.head()</span></code></pre></div>
+<pre><code>##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]</code></pre>
+<div class="sourceCode" id="cb72"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb72-1"><a href="data-wrangling-part-1.html#cb72-1" tabindex="-1"></a>mutation.head()</span></code></pre></div>
+<pre><code>##       ModelID  CACNA1D_Mut  CYP2D6_Mut  ...  CCDC28A_Mut  C1orf194_Mut  U2AF1_Mut
+## 0  ACH-000001        False       False  ...        False         False      False
+## 1  ACH-000002        False       False  ...        False         False      False
+## 2  ACH-000004        False       False  ...        False         False      False
+## 3  ACH-000005        False       False  ...        False         False      False
+## 4  ACH-000006        False       False  ...        False         False      False
+## 
+## [5 rows x 540 columns]</code></pre>
+<div class="sourceCode" id="cb74"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb74-1"><a href="data-wrangling-part-1.html#cb74-1" tabindex="-1"></a>expression.head()</span></code></pre></div>
+<pre><code>##       ModelID  ENPP4_Exp  CREBBP_Exp  ...  OR5D13_Exp  C2orf81_Exp  OR8S1_Exp
+## 0  ACH-001113   2.280956    4.094236  ...         0.0     1.726831        0.0
+## 1  ACH-001289   3.622930    3.606442  ...         0.0     0.790772        0.0
+## 2  ACH-001339   0.790772    2.970854  ...         0.0     0.575312        0.0
+## 3  ACH-001538   3.485427    2.801159  ...         0.0     1.077243        0.0
+## 4  ACH-000242   0.879706    3.327687  ...         0.0     0.722466        0.0
+## 
+## [5 rows x 536 columns]</code></pre>
+<table>
+<colgroup>
+<col width="23%" />
+<col width="23%" />
+<col width="27%" />
+<col width="25%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Dataframe</th>
+<th>The observation is</th>
+<th>Some variables are</th>
+<th>Some values are</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>metadata</td>
+<td>Cell line</td>
+<td>ModelID, Age, OncotreeLineage</td>
+<td>“ACH-000001”, 60, “Myeloid”</td>
+</tr>
+<tr class="even">
+<td>expression</td>
+<td>Cell line</td>
+<td>KRAS_Exp</td>
+<td>2.4, .3</td>
+</tr>
+<tr class="odd">
+<td>mutation</td>
+<td>Cell line</td>
+<td>KRAS_Mut</td>
+<td>TRUE, FALSE</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div id="transform-what-do-you-want-to-do-with-this-dataframe" class="section level2 hasAnchor" number="3.3">
+<h2><span class="header-section-number">3.3</span> Transform: “What do you want to do with this Dataframe”?<a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Remember that a major theme of the course is about: <strong>How we organize ideas &lt;-&gt; Instructing a computer to do something.</strong></p>
+<p>Until now, we haven’t focused too much on how we organize our scientific ideas to interact with what we can do with code. Let’s pivot to write our code driven by our scientific curiosity. After we are sure that we are working with Tidy data, we can ponder how we want to transform our data that satisfies our scientific question. We will look at several ways we can transform Tidy data, starting with subsetting columns and rows.</p>
+<p>Here’s a starting prompt:</p>
+<blockquote>
+<p>In the <code>metadata</code> dataframe, which rows would you subset for and columns would you subset for that relate to a scientific question?</p>
+</blockquote>
+<p>We have been using <strong>explicit subsetting</strong> with numerical indicies, such as “I want to filter for rows 20-50 and select columns 2 and 8”. We are now going to switch to <strong>implicit subsetting</strong> in which we describe the subsetting criteria via comparision operators and column names, such as:</p>
+<p><em>“I want to subset for rows such that the OncotreeLineage is breast cancer and subset for columns Age and Sex.”</em></p>
+<p>Notice that when we subset for rows in an implicit way, we formulate our criteria in terms of the columns.This is because we are guaranteed to have column names in Dataframes, but not row names.</p>
+<div id="lets-convert-our-implicit-subsetting-criteria-into-code" class="section level4 hasAnchor" number="3.3.0.1">
+<h4><span class="header-section-number">3.3.0.1</span> Let’s convert our implicit subsetting criteria into code!<a href="data-wrangling-part-1.html#lets-convert-our-implicit-subsetting-criteria-into-code" class="anchor-section" aria-label="Anchor link to header"></a></h4>
+<p>To subset for rows implicitly, we will use the conditional operators on Dataframe columns you used in Exercise 2. To formulate a conditional operator expression that OncotreeLineage is breast cancer:</p>
+<div class="sourceCode" id="cb76"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb76-1"><a href="data-wrangling-part-1.html#cb76-1" tabindex="-1"></a>metadata[<span class="st">&#39;OncotreeLineage&#39;</span>] <span class="op">==</span> <span class="st">&quot;Lung&quot;</span></span></code></pre></div>
+<pre><code>## 0       False
+## 1       False
+## 2       False
+## 3       False
+## 4       False
+##         ...  
+## 1859    False
+## 1860    False
+## 1861    False
+## 1862    False
+## 1863     True
+## Name: OncotreeLineage, Length: 1864, dtype: bool</code></pre>
+<p>Then, we will use the <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html"><code>.loc</code></a> operation (which is different than <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html"><code>.iloc</code></a> operation!) and subsetting brackets to subset rows and columns Age and Sex at the same time:</p>
+<div class="sourceCode" id="cb78"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb78-1"><a href="data-wrangling-part-1.html#cb78-1" tabindex="-1"></a>metadata.loc[metadata[<span class="st">&#39;OncotreeLineage&#39;</span>] <span class="op">==</span> <span class="st">&quot;Lung&quot;</span>, [<span class="st">&quot;Age&quot;</span>, <span class="st">&quot;Sex&quot;</span>]]</span></code></pre></div>
+<pre><code>##        Age     Sex
+## 10    39.0  Female
+## 13    44.0    Male
+## 19    55.0  Female
+## 27    39.0  Female
+## 28    45.0    Male
+## ...    ...     ...
+## 1745  52.0    Male
+## 1819  84.0    Male
+## 1820  57.0  Female
+## 1822  53.0    Male
+## 1863  62.0    Male
+## 
+## [241 rows x 2 columns]</code></pre>
+<p>What’s going on here? The first component of the subset, <code>metadata['OncotreeLineage'] == "Lung"</code>, subsets for the rows. It gives us a column of <code>True</code> and <code>False</code> values, and we keep rows that correspond to <code>True</code> values. Then, we specify the column names we want to subset for via a list.</p>
+<p>Here’s another example:</p>
+<div class="sourceCode" id="cb80"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb80-1"><a href="data-wrangling-part-1.html#cb80-1" tabindex="-1"></a>df <span class="op">=</span> pd.DataFrame(data<span class="op">=</span>{<span class="st">&#39;status&#39;</span>: [<span class="st">&quot;treated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;discharged&quot;</span>, <span class="st">&quot;treated&quot;</span>],</span>
+<span id="cb80-2"><a href="data-wrangling-part-1.html#cb80-2" tabindex="-1"></a>                            <span class="st">&#39;age_case&#39;</span>: [<span class="dv">25</span>, <span class="dv">43</span>, <span class="dv">21</span>, <span class="dv">65</span>, <span class="dv">7</span>],</span>
+<span id="cb80-3"><a href="data-wrangling-part-1.html#cb80-3" tabindex="-1"></a>                            <span class="st">&#39;age_control&#39;</span>: [<span class="dv">49</span>, <span class="dv">20</span>, <span class="dv">32</span>, <span class="dv">25</span>, <span class="dv">32</span>]})</span>
+<span id="cb80-4"><a href="data-wrangling-part-1.html#cb80-4" tabindex="-1"></a>                            </span>
+<span id="cb80-5"><a href="data-wrangling-part-1.html#cb80-5" tabindex="-1"></a>df</span></code></pre></div>
+<pre><code>##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32</code></pre>
+<p><em>“I want to subset for rows such that the status is”treated” and subset for columns status and age_case.”</em></p>
+<div class="sourceCode" id="cb82"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb82-1"><a href="data-wrangling-part-1.html#cb82-1" tabindex="-1"></a>df.loc[df.status <span class="op">==</span> <span class="st">&quot;treated&quot;</span>, [<span class="st">&quot;status&quot;</span>, <span class="st">&quot;age_case&quot;</span>]]</span></code></pre></div>
+<pre><code>##     status  age_case
+## 0  treated        25
+## 4  treated         7</code></pre>
+<p><img src="images/pandas_subset_2.png" /></p>
+</div>
+</div>
+<div id="summary-statistics" class="section level2 hasAnchor" number="3.4">
+<h2><span class="header-section-number">3.4</span> Summary Statistics<a href="data-wrangling-part-1.html#summary-statistics" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Now that your Dataframe has be transformed based on your scientific question, you can start doing some analysis on it! A common data science task is to examine summary statistics of a dataset, which summarizes the all the values from a variable in a numeric summary, such as mean, median, or mode.</p>
+<p>If we look at the data structure of a Dataframe’s column, it is actually not a List, but an object called Series. It has methods can compute summary statistics for us. Let’s take a look at a few popular examples:</p>
+<table style="width:100%;">
+<colgroup>
+<col width="22%" />
+<col width="22%" />
+<col width="33%" />
+<col width="22%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Function method</th>
+<th>What it takes in</th>
+<th>What it does</th>
+<th>Returns</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.mean.html"><code>metadata.Age.mean()</code></a></td>
+<td><code>metadata.Age</code> as a numeric Series</td>
+<td>Computes the mean value of the <code>Age</code> column.</td>
+<td>Float (NumPy)</td>
+</tr>
+<tr class="even">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.median.html"><code>metadata['Age'].median()</code></a></td>
+<td><code>metadata['Age']</code> as a numeric Series</td>
+<td>Computes the median value of the <code>Age</code> column.</td>
+<td>Float (NumPy)</td>
+</tr>
+<tr class="odd">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.max.html"><code>metadata.Age.max()</code></a></td>
+<td><code>metadata.Age</code> as a numeric Series</td>
+<td>Computes the max value of the <code>Age</code> column.</td>
+<td>Float (NumPy)</td>
+</tr>
+<tr class="even">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.value_counts.html"><code>metadata.OncotreeSubtype.value_counts()</code></a></td>
+<td><code>metadata.OncotreeSubtype</code> as a string Series</td>
+<td>Creates a frequency table of all unique elements in <code>OncotreeSubtype</code> column.</td>
+<td>Series</td>
+</tr>
+</tbody>
+</table>
+<p>Let’s try it out, with some nice print formatting:</p>
+<div class="sourceCode" id="cb84"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb84-1"><a href="data-wrangling-part-1.html#cb84-1" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Mean value of Age column:&quot;</span>, metadata[<span class="st">&#39;Age&#39;</span>].mean())</span></code></pre></div>
+<pre><code>## Mean value of Age column: 47.45187165775401</code></pre>
+<div class="sourceCode" id="cb86"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb86-1"><a href="data-wrangling-part-1.html#cb86-1" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Frequency of column&quot;</span>, metadata.OncotreeLineage.value_counts())</span></code></pre></div>
+<pre><code>## Frequency of column OncotreeLineage
+## Lung                         241
+## Lymphoid                     209
+## CNS/Brain                    123
+## Skin                         118
+## Esophagus/Stomach             95
+## Breast                        92
+## Bowel                         87
+## Head and Neck                 81
+## Myeloid                       77
+## Bone                          75
+## Ovary/Fallopian Tube          74
+## Pancreas                      65
+## Kidney                        64
+## Peripheral Nervous System     55
+## Soft Tissue                   54
+## Uterus                        41
+## Fibroblast                    41
+## Biliary Tract                 40
+## Bladder/Urinary Tract         39
+## Normal                        39
+## Pleura                        35
+## Liver                         28
+## Cervix                        25
+## Eye                           19
+## Thyroid                       18
+## Prostate                      14
+## Vulva/Vagina                   5
+## Ampulla of Vater               4
+## Testis                         4
+## Adrenal Gland                  1
+## Other                          1
+## Name: count, dtype: int64</code></pre>
+<p>Notice that the output of some of these methods are Float (NumPy). This refers to a Python Object called NumPy that is extremely popular for scientific computing, but we’re not focused on that in this course.)</p>
+</div>
+<div id="simple-data-visualization" class="section level2 hasAnchor" number="3.5">
+<h2><span class="header-section-number">3.5</span> Simple data visualization<a href="data-wrangling-part-1.html#simple-data-visualization" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>We will dedicate extensive time later this course to talk about data visualization, but the Dataframe’s column, Series, has a method called <a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.plot.html"><code>.plot()</code></a> that can help us make simple plots for one variable. The <code>.plot()</code> method will by default make a line plot, but it is not necessary the plot style we want, so we can give the optional argument <code>kind</code> a String value to specify the plot style. We use it for making a histogram or bar plot.</p>
+<table>
+<colgroup>
+<col width="18%" />
+<col width="18%" />
+<col width="18%" />
+<col width="45%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Plot style</th>
+<th>Useful for</th>
+<th>kind =</th>
+<th>Code</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Histogram</td>
+<td>Numerics</td>
+<td>“hist”</td>
+<td><code>metadata.Age.plot(kind = "hist")</code></td>
+</tr>
+<tr class="even">
+<td>Bar plot</td>
+<td>Strings</td>
+<td>“bar”</td>
+<td><code>metadata.OncotreeSubtype.value_counts().plot(kind = "bar")</code></td>
+</tr>
+</tbody>
+</table>
+<p>Let’s look at a histogram:</p>
+<div class="sourceCode" id="cb88"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb88-1"><a href="data-wrangling-part-1.html#cb88-1" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
+<span id="cb88-2"><a href="data-wrangling-part-1.html#cb88-2" tabindex="-1"></a></span>
+<span id="cb88-3"><a href="data-wrangling-part-1.html#cb88-3" tabindex="-1"></a>plt.figure()</span>
+<span id="cb88-4"><a href="data-wrangling-part-1.html#cb88-4" tabindex="-1"></a>metadata.Age.plot(kind <span class="op">=</span> <span class="st">&quot;hist&quot;</span>)</span>
+<span id="cb88-5"><a href="data-wrangling-part-1.html#cb88-5" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png" width="672" /></p>
+<p>Let’s look at a bar plot:</p>
+<div class="sourceCode" id="cb89"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb89-1"><a href="data-wrangling-part-1.html#cb89-1" tabindex="-1"></a>plt.figure()</span>
+<span id="cb89-2"><a href="data-wrangling-part-1.html#cb89-2" tabindex="-1"></a>metadata.OncotreeLineage.value_counts().plot(kind <span class="op">=</span> <span class="st">&quot;bar&quot;</span>)</span>
+<span id="cb89-3"><a href="data-wrangling-part-1.html#cb89-3" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png" width="672" /></p>
+<p>(The <code>plt.figure()</code> and <code>plt.show()</code> functions are used to render the plots on the website, but you don’t need to use it for your exercises. We will discuss this in more detail during our week of data visualization.)</p>
+<div id="chained-function-calls" class="section level4 hasAnchor" number="3.5.0.1">
+<h4><span class="header-section-number">3.5.0.1</span> Chained function calls<a href="data-wrangling-part-1.html#chained-function-calls" class="anchor-section" aria-label="Anchor link to header"></a></h4>
+<p>Let’s look at our bar plot syntax more carefully. We start with the column <code>metadata.OncotreeLineage</code>, and then we first use the method <code>.value_counts()</code> to get a <em>Series</em> of a frequency table. Then, we take the frequency table Series and use the <code>.plot()</code> method.</p>
+<p>It is quite common in Python to have multiple “chained” function calls, in which the output of <code>.value_counts()</code> is used for the input of <code>.plot()</code> all in one line of code. It takes a bit of time to get used to this!</p>
+<p>Here’s another example of a chained function call, which looks quite complex, but let’s break it down:</p>
+<div class="sourceCode" id="cb90"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb90-1"><a href="data-wrangling-part-1.html#cb90-1" tabindex="-1"></a>plt.figure()</span>
+<span id="cb90-2"><a href="data-wrangling-part-1.html#cb90-2" tabindex="-1"></a></span>
+<span id="cb90-3"><a href="data-wrangling-part-1.html#cb90-3" tabindex="-1"></a>metadata.loc[metadata.AgeCategory <span class="op">==</span> <span class="st">&quot;Adult&quot;</span>, ].OncotreeLineage.value_counts().plot(kind<span class="op">=</span><span class="st">&quot;bar&quot;</span>)</span>
+<span id="cb90-4"><a href="data-wrangling-part-1.html#cb90-4" tabindex="-1"></a></span>
+<span id="cb90-5"><a href="data-wrangling-part-1.html#cb90-5" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png" width="672" /></p>
+<ol style="list-style-type: decimal">
+<li>We first take the entire <code>metadata</code> and do some subsetting, which outputs a Dataframe.</li>
+<li>We access the <code>OncotreeLineage</code> column, which outputs a Series.</li>
+<li>We use the method <code>.value_counts()</code>, which outputs a Series.</li>
+<li>We make a plot out of it!</li>
+</ol>
+<p>We could have, alternatively, done this in several lines of code:</p>
+<div class="sourceCode" id="cb91"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb91-1"><a href="data-wrangling-part-1.html#cb91-1" tabindex="-1"></a>plt.figure()</span>
+<span id="cb91-2"><a href="data-wrangling-part-1.html#cb91-2" tabindex="-1"></a></span>
+<span id="cb91-3"><a href="data-wrangling-part-1.html#cb91-3" tabindex="-1"></a>metadata_subset <span class="op">=</span> metadata.loc[metadata.AgeCategory <span class="op">==</span> <span class="st">&quot;Adult&quot;</span>, ]</span>
+<span id="cb91-4"><a href="data-wrangling-part-1.html#cb91-4" tabindex="-1"></a>metadata_subset_lineage <span class="op">=</span> metadata_subset.OncotreeLineage</span>
+<span id="cb91-5"><a href="data-wrangling-part-1.html#cb91-5" tabindex="-1"></a>lineage_freq <span class="op">=</span> metadata_subset_lineage.value_counts()</span>
+<span id="cb91-6"><a href="data-wrangling-part-1.html#cb91-6" tabindex="-1"></a>lineage_freq.plot(kind <span class="op">=</span> <span class="st">&quot;bar&quot;</span>)</span>
+<span id="cb91-7"><a href="data-wrangling-part-1.html#cb91-7" tabindex="-1"></a></span>
+<span id="cb91-8"><a href="data-wrangling-part-1.html#cb91-8" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png" width="672" /></p>
+<p>These are two different <em>styles</em> of code, but they do the exact same thing. It’s up to you to decide what is easier for you to understand.</p>
+</div>
+</div>
+<div id="exercises-2" class="section level2 hasAnchor" number="3.6">
+<h2><span class="header-section-number">3.6</span> Exercises<a href="data-wrangling-part-1.html#exercises-2" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 3 can be found <a href="https://colab.research.google.com/drive/1ClNOJviyrcaaoVq5F-YtsO7NhMqn315c?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="working-with-data-structures.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-wrangling-part-2.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/data-wrangling-part-2.html b/docs/data-wrangling-part-2.html
new file mode 100644
index 0000000..3e87bd8
--- /dev/null
+++ b/docs/data-wrangling-part-2.html
@@ -0,0 +1,660 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 4 Data Wrangling, Part 2 | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 4 Data Wrangling, Part 2 | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 4 Data Wrangling, Part 2 | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="data-wrangling-part-1.html"/>
+<link rel="next" href="data-visualization.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="data-wrangling-part-2" class="section level1 hasAnchor" number="4">
+<h1><span class="header-section-number">Chapter 4</span> Data Wrangling, Part 2<a href="data-wrangling-part-2.html#data-wrangling-part-2" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>We will continue to learn about data analysis with Dataframes. Let’s load our three Dataframes from the Depmap project in again:</p>
+<div class="sourceCode" id="cb92"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb92-1"><a href="data-wrangling-part-2.html#cb92-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb92-2"><a href="data-wrangling-part-2.html#cb92-2" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb92-3"><a href="data-wrangling-part-2.html#cb92-3" tabindex="-1"></a></span>
+<span id="cb92-4"><a href="data-wrangling-part-2.html#cb92-4" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb92-5"><a href="data-wrangling-part-2.html#cb92-5" tabindex="-1"></a>mutation <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/mutation.csv&quot;</span>)</span>
+<span id="cb92-6"><a href="data-wrangling-part-2.html#cb92-6" tabindex="-1"></a>expression <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/expression.csv&quot;</span>)</span></code></pre></div>
+<div id="creating-new-columns" class="section level2 hasAnchor" number="4.1">
+<h2><span class="header-section-number">4.1</span> Creating new columns<a href="data-wrangling-part-2.html#creating-new-columns" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Often, we want to perform some kind of transformation on our data’s columns: perhaps you want to add the values of columns together, or perhaps you want to represent your column in a different scale.</p>
+<p>To create a new column, you simply modify it as if it exists using the bracket operation <code>[ ]</code>, and the column will be created:</p>
+<div class="sourceCode" id="cb93"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb93-1"><a href="data-wrangling-part-2.html#cb93-1" tabindex="-1"></a>metadata[<span class="st">&#39;AgePlusTen&#39;</span>] <span class="op">=</span> metadata[<span class="st">&#39;Age&#39;</span>] <span class="op">+</span> <span class="dv">10</span></span>
+<span id="cb93-2"><a href="data-wrangling-part-2.html#cb93-2" tabindex="-1"></a>expression[<span class="st">&#39;KRAS_NRAS_exp&#39;</span>] <span class="op">=</span> expression[<span class="st">&#39;KRAS_Exp&#39;</span>] <span class="op">+</span> expression[<span class="st">&#39;NRAS_Exp&#39;</span>]</span>
+<span id="cb93-3"><a href="data-wrangling-part-2.html#cb93-3" tabindex="-1"></a>expression[<span class="st">&#39;log_PIK3CA_Exp&#39;</span>] <span class="op">=</span> np.log(expression[<span class="st">&#39;PIK3CA_Exp&#39;</span>])</span></code></pre></div>
+<p>where <a href="https://numpy.org/doc/stable/reference/generated/numpy.log.html"><code>np.log(x)</code></a> is a function imported from the module NumPy that takes in a numeric and returns the log-transformed value.</p>
+<p>Note: you cannot create a new column referring to the attribute of the Dataframe, such as: <code>expression.KRAS_Exp_log = np.log(expression.KRAS_Exp)</code>.</p>
+</div>
+<div id="merging-two-dataframes-together" class="section level2 hasAnchor" number="4.2">
+<h2><span class="header-section-number">4.2</span> Merging two Dataframes together<a href="data-wrangling-part-2.html#merging-two-dataframes-together" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Suppose we have the following Dataframes:</p>
+<p><code>expression</code></p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>PIK3CA_Exp</th>
+<th>log_PIK3CA_Exp</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>5.138733</td>
+<td>1.636806</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>3.184280</td>
+<td>1.158226</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>3.165108</td>
+<td>1.152187</td>
+</tr>
+</tbody>
+</table>
+<p><code>metadata</code></p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>OncotreeLineage</th>
+<th>Age</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>“Lung”</td>
+<td>69</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>“CNS/Brain”</td>
+<td>NaN</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+</tbody>
+</table>
+<p>Suppose that I want to compare the relationship between <code>OncotreeLineage</code> and <code>PIK3CA_Exp</code>, but they are columns in different Dataframes. We want a new Dataframe that looks like this:</p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>PIK3CA_Exp</th>
+<th>log_PIK3CA_Exp</th>
+<th>OncotreeLineage</th>
+<th>Age</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>5.138733</td>
+<td>1.636806</td>
+<td>“Lung”</td>
+<td>69</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>3.184280</td>
+<td>1.158226</td>
+<td>“CNS/Brain”</td>
+<td>NaN</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>3.165108</td>
+<td>1.152187</td>
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+</tbody>
+</table>
+<p>We see that in both dataframes,</p>
+<ul>
+<li><p>the rows (observations) represent cell lines.</p></li>
+<li><p>there is a common column <code>ModelID</code>, with shared values between the two dataframes that can faciltate the merging process. We call this an <strong>index</strong>.</p></li>
+</ul>
+<p>We will use the method <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html"><code>.merge()</code></a> for Dataframes. It takes a Dataframe to merge with as the required input argument. The method looks for a common index column between the two dataframes and merge based on that index.</p>
+<div class="sourceCode" id="cb94"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb94-1"><a href="data-wrangling-part-2.html#cb94-1" tabindex="-1"></a>merged <span class="op">=</span> metadata.merge(expression)</span></code></pre></div>
+<p>It’s usually better to specify what that index column to avoid ambiguity, using the <code>on</code> optional argument:</p>
+<div class="sourceCode" id="cb95"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb95-1"><a href="data-wrangling-part-2.html#cb95-1" tabindex="-1"></a>merged <span class="op">=</span> metadata.merge(expression, on<span class="op">=</span><span class="st">&#39;ModelID&#39;</span>)</span></code></pre></div>
+<p>If the index column for the two Dataframes are named differently, you can specify the column name for each Dataframe:</p>
+<div class="sourceCode" id="cb96"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb96-1"><a href="data-wrangling-part-2.html#cb96-1" tabindex="-1"></a>merged <span class="op">=</span> metadata.merge(expression, left_on<span class="op">=</span><span class="st">&#39;ModelID&#39;</span>, right_on<span class="op">=</span><span class="st">&#39;ModelID&#39;</span>)</span></code></pre></div>
+<p>One of the most import checks you should do when merging dataframes is to look at the number of rows and columns before and after merging to see whether it makes sense or not:</p>
+<p>The number of rows and columns of <code>metadata</code>:</p>
+<div class="sourceCode" id="cb97"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb97-1"><a href="data-wrangling-part-2.html#cb97-1" tabindex="-1"></a>metadata.shape</span></code></pre></div>
+<pre><code>## (1864, 31)</code></pre>
+<p>The number of rows and columns of <code>expression</code>:</p>
+<div class="sourceCode" id="cb99"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb99-1"><a href="data-wrangling-part-2.html#cb99-1" tabindex="-1"></a>expression.shape</span></code></pre></div>
+<pre><code>## (1450, 538)</code></pre>
+<p>The number of rows and columns of <code>merged</code>:</p>
+<div class="sourceCode" id="cb101"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb101-1"><a href="data-wrangling-part-2.html#cb101-1" tabindex="-1"></a>merged.shape</span></code></pre></div>
+<pre><code>## (1450, 568)</code></pre>
+<p>We see that the number of <em>columns</em> in <code>merged</code> combines the number of columns in <code>metadata</code> and <code>expression</code>, while the number of <em>rows</em> in <code>merged</code> is the smaller of the number of rows in <code>metadata</code> and <code>expression</code>: it only keeps rows that are found in both Dataframe’s index columns. This kind of join is called “inner join”, because in the Venn Diagram of elements common in both index column, we keep the inner overlap:</p>
+<p><img src="images/join.png" /></p>
+<p>You can specifiy the join style by changing the optional input argument <code>how</code>.</p>
+<ul>
+<li><p><code>how = "outer"</code> keeps all observations - also known as a “full join”</p></li>
+<li><p><code>how = "left"</code> keeps all observations in the left Dataframe.</p></li>
+<li><p><code>how = "right"</code> keeps all observations in the right Dataframe.</p></li>
+<li><p><code>how = "inner"</code> keeps observations common to both Dataframe. This is the default value of <code>how</code>.</p></li>
+</ul>
+</div>
+<div id="grouping-and-summarizing-dataframes" class="section level2 hasAnchor" number="4.3">
+<h2><span class="header-section-number">4.3</span> Grouping and summarizing Dataframes<a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>In a dataset, there may be groups of observations that we want to understand, such as case vs. control, or comparing different cancer subtypes. For example, in <code>metadata</code>, the observation is cell lines, and perhaps we want to group cell lines into their respective cancer type, <code>OncotreeLineage</code>, and look at the mean age for each cancer type.</p>
+<p>We want to take <code>metadata</code>:</p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>OncotreeLineage</th>
+<th>Age</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>“Lung”</td>
+<td>69</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>“Lung”</td>
+<td>23</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+<tr class="even">
+<td>“ACH-002342”</td>
+<td>“Brain”</td>
+<td>23</td>
+</tr>
+<tr class="odd">
+<td>“ACH-004854”</td>
+<td>“Brain”</td>
+<td>56</td>
+</tr>
+<tr class="even">
+<td>“ACH-002921”</td>
+<td>“Brain”</td>
+<td>67</td>
+</tr>
+</tbody>
+</table>
+<p>into:</p>
+<table>
+<thead>
+<tr class="header">
+<th>OncotreeLineage</th>
+<th>MeanAge</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“Lung”</td>
+<td>46</td>
+</tr>
+<tr class="even">
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+<tr class="odd">
+<td>“Brain”</td>
+<td>48.67</td>
+</tr>
+</tbody>
+</table>
+<p>To get there, we need to:</p>
+<ul>
+<li><p><strong>Group</strong> the data based on some criteria, elements of <code>OncotreeLineage</code></p></li>
+<li><p><strong>Summarize</strong> each group via a summary statistic performed on a column, such as <code>Age</code>.</p></li>
+</ul>
+<p>We first subset the the two columns we need, and then use the methods <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html"><code>.group_by(x)</code></a> and <code>.mean()</code>.</p>
+<div class="sourceCode" id="cb103"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb103-1"><a href="data-wrangling-part-2.html#cb103-1" tabindex="-1"></a>metadata_grouped <span class="op">=</span> metadata.groupby(<span class="st">&quot;OncotreeLineage&quot;</span>)</span>
+<span id="cb103-2"><a href="data-wrangling-part-2.html#cb103-2" tabindex="-1"></a>metadata_grouped[<span class="st">&#39;Age&#39;</span>].mean()</span></code></pre></div>
+<pre><code>## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64</code></pre>
+<p>Here’s what’s going on:</p>
+<ul>
+<li><p>We use the Dataframe method <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html"><code>.group_by(x)</code></a> and specify the column we want to group by. The output of this method is a Grouped Dataframe object. It still contains all the information of the <code>metadata</code> Dataframe, but it makes a note that it’s been grouped.</p></li>
+<li><p>We subset to the column <code>Age</code>. The grouping information still persists (This is a Grouped Series object).</p></li>
+<li><p>We use the method <code>.mean()</code> to calculate the mean value of <code>Age</code> within each group defined by <code>OncotreeLineage</code>.</p></li>
+</ul>
+<p>Alternatively, this could have been done in a chain of methods:</p>
+<div class="sourceCode" id="cb105"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb105-1"><a href="data-wrangling-part-2.html#cb105-1" tabindex="-1"></a>metadata.groupby(<span class="st">&quot;OncotreeLineage&quot;</span>)[<span class="st">&quot;Age&quot;</span>].mean()</span></code></pre></div>
+<pre><code>## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64</code></pre>
+<p>Once a Dataframe has been grouped and a column is selected, all the summary statistics methods you learned from last week, such as <code>.mean()</code>, <code>.median()</code>, <code>.max()</code>, can be used. One new summary statistics method that is useful for this grouping and summarizing analysis is <a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.count.html"><code>.count()</code></a> which tells you how many entries are counted within each group.</p>
+<div id="optional-multiple-grouping-multiple-columns-multiple-summary-statistics" class="section level3 hasAnchor" number="4.3.1">
+<h3><span class="header-section-number">4.3.1</span> Optional: Multiple grouping, Multiple columns, Multiple summary statistics<a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>Sometimes, when performing grouping and summary analysis, you want to operate on multiple columns simultaneously.</p>
+<p>For example, you may want to group by a combination of <code>OncotreeLineage</code> and <code>AgeCategory</code>, such as “Lung” and “Adult” as one grouping. You can do so like this:</p>
+<div class="sourceCode" id="cb107"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb107-1"><a href="data-wrangling-part-2.html#cb107-1" tabindex="-1"></a>metadata_grouped <span class="op">=</span> metadata.groupby([<span class="st">&quot;OncotreeLineage&quot;</span>, <span class="st">&quot;AgeCategory&quot;</span>])</span>
+<span id="cb107-2"><a href="data-wrangling-part-2.html#cb107-2" tabindex="-1"></a>metadata_grouped[<span class="st">&#39;Age&#39;</span>].mean()</span></code></pre></div>
+<pre><code>## OncotreeLineage   AgeCategory
+## Adrenal Gland     Adult          55.000000
+## Ampulla of Vater  Adult          65.500000
+##                   Unknown              NaN
+## Biliary Tract     Adult          58.450000
+##                   Unknown              NaN
+##                                    ...    
+## Thyroid           Unknown              NaN
+## Uterus            Adult          62.060606
+##                   Fetus                NaN
+##                   Unknown              NaN
+## Vulva/Vagina      Adult          75.400000
+## Name: Age, Length: 72, dtype: float64</code></pre>
+<p>You can also summarize on multiple columns simultaneously. For each column, you have to specify what summary statistic functions you want to use. This can be specified via the <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.agg.html"><code>.agg(x)</code></a> method on a Grouped Dataframe.</p>
+<p>For example, coming back to our age case-control Dataframe,</p>
+<div class="sourceCode" id="cb109"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb109-1"><a href="data-wrangling-part-2.html#cb109-1" tabindex="-1"></a>df <span class="op">=</span> pd.DataFrame(data<span class="op">=</span>{<span class="st">&#39;status&#39;</span>: [<span class="st">&quot;treated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;discharged&quot;</span>, <span class="st">&quot;treated&quot;</span>],</span>
+<span id="cb109-2"><a href="data-wrangling-part-2.html#cb109-2" tabindex="-1"></a>                            <span class="st">&#39;age_case&#39;</span>: [<span class="dv">25</span>, <span class="dv">43</span>, <span class="dv">21</span>, <span class="dv">65</span>, <span class="dv">7</span>],</span>
+<span id="cb109-3"><a href="data-wrangling-part-2.html#cb109-3" tabindex="-1"></a>                            <span class="st">&#39;age_control&#39;</span>: [<span class="dv">49</span>, <span class="dv">20</span>, <span class="dv">32</span>, <span class="dv">25</span>, <span class="dv">32</span>]})</span>
+<span id="cb109-4"><a href="data-wrangling-part-2.html#cb109-4" tabindex="-1"></a>                            </span>
+<span id="cb109-5"><a href="data-wrangling-part-2.html#cb109-5" tabindex="-1"></a>df</span></code></pre></div>
+<pre><code>##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32</code></pre>
+<p>We group by <code>status</code> and summarize <code>age_case</code> and <code>age_control</code> with a few summary statistics each:</p>
+<div class="sourceCode" id="cb111"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb111-1"><a href="data-wrangling-part-2.html#cb111-1" tabindex="-1"></a>df.groupby(<span class="st">&quot;status&quot;</span>).agg({<span class="st">&quot;age_case&quot;</span>: <span class="st">&quot;mean&quot;</span>, <span class="st">&quot;age_control&quot;</span>: [<span class="st">&quot;min&quot;</span>, <span class="st">&quot;max&quot;</span>, <span class="st">&quot;mean&quot;</span>]})</span></code></pre></div>
+<pre><code>##            age_case age_control          
+##                mean         min max  mean
+## status                                   
+## discharged     65.0          25  25  25.0
+## treated        16.0          32  49  40.5
+## untreated      32.0          20  32  26.0</code></pre>
+<p>The input argument to the <code>.agg(x)</code> method is called a <a href="https://docs.python.org/3/tutorial/datastructures.html#dictionaries">Dictionary</a>, which let’s you structure information in a paired relationship. You can learn more about dictionaries here.</p>
+</div>
+</div>
+<div id="exercises-3" class="section level2 hasAnchor" number="4.4">
+<h2><span class="header-section-number">4.4</span> Exercises<a href="data-wrangling-part-2.html#exercises-3" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 4 can be found <a href="https://colab.research.google.com/drive/1ntkUdKQ209vu1M89rcsBst-pKKuwzdwX?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="data-wrangling-part-1.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-visualization.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/data-wrangling.html b/docs/data-wrangling.html
new file mode 100644
index 0000000..b3024ac
--- /dev/null
+++ b/docs/data-wrangling.html
@@ -0,0 +1,303 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 3 Data Wrangling | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 3 Data Wrangling | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 3 Data Wrangling | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="working-with-data-structures.html"/>
+<link rel="next" href="about-the-authors.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.2</b> Function machine schema</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.3</b> Dataframes</a>
+<ul>
+<li class="chapter" data-level="2.3.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain-in-terms-of-data"><i class="fa fa-check"></i><b>2.3.1</b> What does a Dataframe contain (in terms of data)?</a></li>
+<li class="chapter" data-level="2.3.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do-in-terms-of-operations-and-functions"><i class="fa fa-check"></i><b>2.3.2</b> What can a Dataframe do (in terms of operations and functions)?</a></li>
+</ul></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling.html"><a href="data-wrangling.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling.html"><a href="data-wrangling.html#exercises-2"><i class="fa fa-check"></i><b>3.1</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="4" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>4</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="data-wrangling" class="section level1 hasAnchor" number="3">
+<h1><span class="header-section-number">Chapter 3</span> Data Wrangling<a href="data-wrangling.html#data-wrangling" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<div id="exercises-2" class="section level2 hasAnchor" number="3.1">
+<h2><span class="header-section-number">3.1</span> Exercises<a href="data-wrangling.html#exercises-2" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 3 can be found <a href="#">here</a></p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="working-with-data-structures.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="about-the-authors.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/images/colab.png b/docs/images/colab.png
new file mode 100644
index 0000000..ccd9004
Binary files /dev/null and b/docs/images/colab.png differ
diff --git a/docs/images/join.png b/docs/images/join.png
new file mode 100644
index 0000000..d408d6b
Binary files /dev/null and b/docs/images/join.png differ
diff --git a/docs/images/pandas subset_1.png b/docs/images/pandas subset_1.png
new file mode 100644
index 0000000..45376f2
Binary files /dev/null and b/docs/images/pandas subset_1.png differ
diff --git a/docs/images/pandas_subset_0.png b/docs/images/pandas_subset_0.png
new file mode 100644
index 0000000..2a37d28
Binary files /dev/null and b/docs/images/pandas_subset_0.png differ
diff --git a/docs/images/pandas_subset_2.png b/docs/images/pandas_subset_2.png
new file mode 100644
index 0000000..eecc68e
Binary files /dev/null and b/docs/images/pandas_subset_2.png differ
diff --git a/docs/index.html b/docs/index.html
index 9e6b078..8204dc7 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -202,7 +246,7 @@ <h1>
 </div>
 <div id="header">
 <h1 class="title">Introduction to Python</h1>
-<p class="date"><em>August, 2024</em></p>
+<p class="date"><em>September, 2024</em></p>
 </div>
 <div id="about-this-course" class="section level1 unnumbered hasAnchor">
 <h1>About this Course<a href="index.html#about-this-course" class="anchor-section" aria-label="Anchor link to header"></a></h1>
diff --git a/docs/index.md b/docs/index.md
index bdb6e62..c4161aa 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,6 +1,6 @@
 ---
 title: "Introduction to Python"
-date: "August, 2024"
+date: "September, 2024"
 site: bookdown::bookdown_site
 documentclass: book
 bibliography: [book.bib]
diff --git a/docs/intro-to-computing.html b/docs/intro-to-computing.html
index dcc75b6..6d0ee0a 100644
--- a/docs/intro-to-computing.html
+++ b/docs/intro-to-computing.html
@@ -29,7 +29,7 @@
   
   <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
 <link rel="prev" href="index.html"/>
-<link rel="next" href="about-the-authors.html"/>
+<link rel="next" href="working-with-data-structures.html"/>
 <script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
 <link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -236,16 +280,17 @@ <h2><span class="header-section-number">1.3</span> A programming language has fo
 <div id="google-colab-setup" class="section level2 hasAnchor" number="1.4">
 <h2><span class="header-section-number">1.4</span> Google Colab Setup<a href="intro-to-computing.html#google-colab-setup" class="anchor-section" aria-label="Anchor link to header"></a></h2>
 <p>Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user.</p>
-<p>Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, open up…</p>
+<p>Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, you can view it <a href="https://colab.research.google.com/drive/1_77QQcj0mgZOWLlhtkZ-QKWUP1dnSt-_?usp=sharing">here</a>.</p>
+<p><img src="images/colab.png" width="800" /></p>
 <p>Today, we will pay close attention to:</p>
 <ul>
-<li><p>Python Console (Execution): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.</p></li>
+<li><p>Python Console (“Executions”): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.</p></li>
 <li><p>Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text <em>and</em> Python code, and it helps us understand better the code we are writing.</p></li>
 <li><p>Variable Environment: Open it by clicking on the “{x}” button on the left-hand panel. Often, your code will store information in the Variable Environment, so that information can be reused. For instance, we often load in data and store it in the Variable Environment, and use it throughout rest of your Python code.</p></li>
 </ul>
 <p>The first thing we will do is see the different ways we can run Python code. You can do the following:</p>
 <ol style="list-style-type: decimal">
-<li>Type something into the Python Console (Execution) and type enter, such as <code>2+2</code>. The Python Console will run it and give you an output.</li>
+<li>Type something into the Python Console (Execution) and click the arrow button, such as <code>2+2</code>. The Python Console will run it and give you an output.</li>
 <li>Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data.</li>
 <li>Run every single Python code chunk via Runtime -&gt; Run all.</li>
 </ol>
@@ -257,13 +302,14 @@ <h2><span class="header-section-number">1.4</span> Google Colab Setup<a href="in
 <li><p>It encourages excellent documentation, as you can have code, output from code, and prose combined together.</p></li>
 <li><p>It is flexible to use other programming languages, such as R.</p></li>
 </ul>
+<p>The version of Python used in this course and in Google Colab is Python 3, which is the version of Python that is most supported. Some Python software is written in Python 2, which is very similar but has some <a href="https://www.fullstackpython.com/python-2-or-3.html">notable differences</a>.</p>
 <p>Now, we will get to the basics of programming grammar.</p>
 </div>
 <div id="grammar-structure-1-evaluation-of-expressions" class="section level2 hasAnchor" number="1.5">
 <h2><span class="header-section-number">1.5</span> Grammar Structure 1: Evaluation of Expressions<a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions" class="anchor-section" aria-label="Anchor link to header"></a></h2>
 <ul>
 <li><p><strong>Expressions</strong> are be built out of <strong>operations</strong> or <strong>functions</strong>.</p></li>
-<li><p>Functions and operations take in <strong>data types</strong>, do something with them, and return another data type.</p></li>
+<li><p>Functions and operations take in <strong>data types</strong> as inputs, do something with them, and <strong>return</strong> another data type as ouput.</p></li>
 <li><p>We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it.</p></li>
 </ul>
 <p>For instance, consider the following expressions entered to the Python Console:</p>
@@ -285,9 +331,22 @@ <h2><span class="header-section-number">1.5</span> Grammar Structure 1: Evaluati
 <pre><code>## 39</code></pre>
 <div class="sourceCode" id="cb13"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb13-1"><a href="intro-to-computing.html#cb13-1" tabindex="-1"></a>add(<span class="dv">18</span>, add(<span class="dv">21</span>, <span class="dv">65</span>))</span></code></pre></div>
 <pre><code>## 104</code></pre>
-<p>Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to <em>readable</em> code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Because the <code>add()</code> function isn’t typically used, it is not automatically available, so we used the import statement to load it in.)</p>
-<div id="data-types" class="section level3 hasAnchor" number="1.5.1">
-<h3><span class="header-section-number">1.5.1</span> Data types<a href="intro-to-computing.html#data-types" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to <em>readable</em> code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Most functions in Python are stored in a collection of functions called <strong>modules</strong> that needs to be loaded. The <code>import</code> statement gives us permission to access the functions in the module “operator”.)</p>
+<div id="function-machine-schema" class="section level3 hasAnchor" number="1.5.1">
+<h3><span class="header-section-number">1.5.1</span> Function machine schema<a href="intro-to-computing.html#function-machine-schema" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:</p>
+<div class="float">
+<img src="images/function_machine.png" alt="Function machine from algebra class." />
+<div class="figcaption">Function machine from algebra class.</div>
+</div>
+<p>Here are some aspects of this schema to pay attention to:</p>
+<ul>
+<li><p>A programmer should not need to know how the function or operation is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.</p></li>
+<li><p>A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the <code>len()</code> function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.</p></li>
+</ul>
+</div>
+<div id="data-types" class="section level3 hasAnchor" number="1.5.2">
+<h3><span class="header-section-number">1.5.2</span> Data types<a href="intro-to-computing.html#data-types" class="anchor-section" aria-label="Anchor link to header"></a></h3>
 <p>Here are some common data types we will be using in this course.</p>
 <table>
 <thead>
@@ -320,16 +379,6 @@ <h3><span class="header-section-number">1.5.1</span> Data types<a href="intro-to
 </tr>
 </tbody>
 </table>
-<p>A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:</p>
-<div class="float">
-<img src="images/function_machine.png" alt="Function machine from algebra class." />
-<div class="figcaption">Function machine from algebra class.</div>
-</div>
-<p>Here are some aspects of this schema to pay attention to:</p>
-<ul>
-<li><p>A programmer should not need to know how the function is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.</p></li>
-<li><p>A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the <code>len()</code> function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.</p></li>
-</ul>
 </div>
 </div>
 <div id="grammar-structure-2-storing-data-types-in-the-variable-environment" class="section level2 hasAnchor" number="1.6">
@@ -342,18 +391,18 @@ <h3><span class="header-section-number">1.6.1</span> Execution rule for variable
 <blockquote>
 <p>Evaluate the expression to the right of <code>=</code>.</p>
 <p>Bind variable to the left of <code>=</code> to the resulting value.</p>
-<p>The variable is stored in the Variable Environment.</p>
+<p>The variable is stored in the <strong>Variable Environment</strong>.</p>
 </blockquote>
 <p>The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined.</p>
-<p>The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. When we work with large datasets, if you assign a variable to a data type larger than the available RAM, it will not work. More on this later.</p>
+<p>The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM.</p>
 <p>Look, now <code>x</code> can be reused downstream:</p>
 <div class="sourceCode" id="cb16"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb16-1"><a href="intro-to-computing.html#cb16-1" tabindex="-1"></a>x <span class="op">-</span> <span class="dv">2</span></span></code></pre></div>
 <pre><code>## 37</code></pre>
 <div class="sourceCode" id="cb18"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb18-1"><a href="intro-to-computing.html#cb18-1" tabindex="-1"></a>y <span class="op">=</span> x <span class="op">*</span> <span class="dv">2</span></span></code></pre></div>
-<p>It is quite common for programmers to not know what data type a variable is while they are coding. To learn about the data type of a variable, use the <code>type()</code> function on any variable in Python:</p>
+<p>It is quite common for programmers to have to look up the data type of a variable while they are coding. To learn about the data type of a variable, use the <code>type()</code> function on any variable in Python:</p>
 <div class="sourceCode" id="cb19"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb19-1"><a href="intro-to-computing.html#cb19-1" tabindex="-1"></a><span class="bu">type</span>(y)</span></code></pre></div>
 <pre><code>## &lt;class &#39;int&#39;&gt;</code></pre>
-<p>We should give useful variable names so that we know what to expect! Consider <code>num_sales</code> instead of <code>y</code>.</p>
+<p>We should give useful variable names so that we know what to expect! If you are working with numerical sales data, consider <code>num_sales</code> instead of <code>y</code>.</p>
 </div>
 </div>
 <div id="grammar-structure-3-evaluation-of-functions" class="section level2 hasAnchor" number="1.7">
@@ -362,13 +411,15 @@ <h2><span class="header-section-number">1.7</span> Grammar Structure 3: Evaluati
 <div id="execution-rule-for-functions" class="section level3 hasAnchor" number="1.7.1">
 <h3><span class="header-section-number">1.7.1</span> Execution rule for functions:<a href="intro-to-computing.html#execution-rule-for-functions" class="anchor-section" aria-label="Anchor link to header"></a></h3>
 <blockquote>
-<p>Evaluate the function by its arguments, and if the arguments are functions or contains operations, evaluate those functions or operations first.</p>
+<p>Evaluate the function by its arguments if there’s any, and if the arguments are functions or contains operations, evaluate those functions or operations first.</p>
 <p>The output of functions is called the <strong>returned value</strong>.</p>
 </blockquote>
-<p>Often, we will use multiple functions, in a nested way, or use parenthesis to change the order of operation. Being able to read nested operations, nested functions, and parenthesis is very important. Think about what the Python is going to do step-by–step in the line of code below:</p>
-<div class="sourceCode" id="cb21"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb21-1"><a href="intro-to-computing.html#cb21-1" tabindex="-1"></a>(<span class="bu">len</span>(<span class="st">&quot;hello&quot;</span>) <span class="op">+</span> <span class="dv">4</span>) <span class="op">*</span> <span class="dv">2</span></span></code></pre></div>
-<pre><code>## 18</code></pre>
-<p>If we don’t know how to use a function, such as <code>pow()</code> we can ask for help:</p>
+<p>Often, we will use multiple functions in a nested way, and it is important to understand how the Python console understand the order of operation. We can also use parenthesis to change the order of operation. Think about what the Python is going to do step-by–step in the lines of code below:</p>
+<div class="sourceCode" id="cb21"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb21-1"><a href="intro-to-computing.html#cb21-1" tabindex="-1"></a><span class="bu">max</span>(<span class="bu">len</span>(<span class="st">&quot;hello&quot;</span>), <span class="dv">4</span>)</span></code></pre></div>
+<pre><code>## 5</code></pre>
+<div class="sourceCode" id="cb23"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb23-1"><a href="intro-to-computing.html#cb23-1" tabindex="-1"></a>(<span class="bu">len</span>(<span class="st">&quot;pumpkin&quot;</span>) <span class="op">-</span> <span class="dv">8</span>) <span class="op">*</span> <span class="dv">2</span></span></code></pre></div>
+<pre><code>## -2</code></pre>
+<p>If we don’t know how to use a function, such as <code>pow()</code>, we can ask for help:</p>
 <pre><code>?pow
 
 pow(base, exp, mod=None)
@@ -376,33 +427,76 @@ <h3><span class="header-section-number">1.7.1</span> Execution rule for function
  
 Some types, such as ints, are able to use a more efficient algorithm when
 invoked using the three argument form.</code></pre>
-<p>This shows the function takes in three input arguments: <code>base</code>, <code>exp</code>, and <code>mod=None</code>. When an argument has an assigned value of <code>mod=None</code>, that means the input argument already has a value, and you don’t need to specify anything, unless you want to.</p>
+<p>We can also find a similar help document, in a <a href="https://docs.python.org/3/library/functions.html#pow">nicer rendered form online.</a> We will practice looking at function documentation throughout the course, because that is a fundamental skill to learn more functions on your own.</p>
+<p>The documentation shows the function takes in three input arguments: <code>base</code>, <code>exp</code>, and <code>mod=None</code>. When an argument has an assigned value of <code>mod=None</code>, that means the input argument already has a value, and you don’t need to specify anything, unless you want to.</p>
 <p>The following ways are equivalent ways of using the <code>pow()</code> function:</p>
-<div class="sourceCode" id="cb24"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb24-1"><a href="intro-to-computing.html#cb24-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">2</span>, <span class="dv">3</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb26"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb26-1"><a href="intro-to-computing.html#cb26-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">2</span>, <span class="dv">3</span>)</span></code></pre></div>
 <pre><code>## 8</code></pre>
-<div class="sourceCode" id="cb26"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb26-1"><a href="intro-to-computing.html#cb26-1" tabindex="-1"></a><span class="bu">pow</span>(base<span class="op">=</span><span class="dv">2</span>, exp<span class="op">=</span><span class="dv">3</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb28"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb28-1"><a href="intro-to-computing.html#cb28-1" tabindex="-1"></a><span class="bu">pow</span>(base<span class="op">=</span><span class="dv">2</span>, exp<span class="op">=</span><span class="dv">3</span>)</span></code></pre></div>
 <pre><code>## 8</code></pre>
-<div class="sourceCode" id="cb28"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb28-1"><a href="intro-to-computing.html#cb28-1" tabindex="-1"></a><span class="bu">pow</span>(exp<span class="op">=</span><span class="dv">3</span>, base<span class="op">=</span><span class="dv">2</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb30"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb30-1"><a href="intro-to-computing.html#cb30-1" tabindex="-1"></a><span class="bu">pow</span>(exp<span class="op">=</span><span class="dv">3</span>, base<span class="op">=</span><span class="dv">2</span>)</span></code></pre></div>
 <pre><code>## 8</code></pre>
 <p>but this will give you something different:</p>
-<div class="sourceCode" id="cb30"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb30-1"><a href="intro-to-computing.html#cb30-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">3</span>, <span class="dv">2</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb32"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb32-1"><a href="intro-to-computing.html#cb32-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">3</span>, <span class="dv">2</span>)</span></code></pre></div>
 <pre><code>## 9</code></pre>
 <p>And there is an operational equivalent:</p>
-<div class="sourceCode" id="cb32"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb32-1"><a href="intro-to-computing.html#cb32-1" tabindex="-1"></a><span class="dv">2</span> <span class="op">**</span> <span class="dv">3</span></span></code></pre></div>
+<div class="sourceCode" id="cb34"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb34-1"><a href="intro-to-computing.html#cb34-1" tabindex="-1"></a><span class="dv">2</span> <span class="op">**</span> <span class="dv">3</span></span></code></pre></div>
 <pre><code>## 8</code></pre>
+<p>We will mostly look at functions with input arguments and return types in this course, but not all functions need to have input arguments and output return. Let’s look at some examples of functions that don’t always have an input or output:</p>
+<table>
+<colgroup>
+<col width="43%" />
+<col width="15%" />
+<col width="36%" />
+<col width="5%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Function call</th>
+<th>What it takes in</th>
+<th>What it does</th>
+<th>Returns</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/library/functions.html#pow"><code>pow(a, b)</code></a></td>
+<td>integer <code>a</code>, integer <code>b</code></td>
+<td>Raises <code>a</code> to the <code>b</code>th power.</td>
+<td>Integer</td>
+</tr>
+<tr class="even">
+<td><a href="https://docs.python.org/3/library/time.html#time.sleep"><code>time.sleep(x)</code></a></td>
+<td>Integer <code>x</code></td>
+<td>Waits for <code>x</code> seconds.</td>
+<td>None</td>
+</tr>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/library/functions.html#dir"><code>dir()</code></a></td>
+<td>Nothing</td>
+<td>Gives a list of all the variables defined in the environment.</td>
+<td>List</td>
+</tr>
+</tbody>
+</table>
 </div>
 </div>
 <div id="tips-on-writing-your-first-code" class="section level2 hasAnchor" number="1.8">
 <h2><span class="header-section-number">1.8</span> Tips on writing your first code<a href="intro-to-computing.html#tips-on-writing-your-first-code" class="anchor-section" aria-label="Anchor link to header"></a></h2>
 <p><code>Computer = powerful + stupid</code></p>
-<p>Even the smallest spelling and formatting changes will cause unexpected output and errors!</p>
+<p>Computers are excellent at doing something specific over and over again, but is extremely rigid and lack flexibility. Here are some tips that is helpful for beginners:</p>
 <ul>
-<li><p>Write incrementally, test often</p></li>
+<li><p>Write incrementally, test often.</p></li>
+<li><p>Don’t be afraid to break things: it is how we learn how things work in programming.</p></li>
 <li><p>Check your assumptions, especially using new functions, operations, and new data types.</p></li>
 <li><p>Live environments are great for testing, but not great for reproducibility.</p></li>
 <li><p>Ask for help!</p></li>
 </ul>
 <p>To get more familiar with the errors Python gives you, take a look at this <a href="https://betterstack.com/community/guides/scaling-python/python-errors/">summary of Python error messages</a>.</p>
+</div>
+<div id="exercises" class="section level2 hasAnchor" number="1.9">
+<h2><span class="header-section-number">1.9</span> Exercises<a href="intro-to-computing.html#exercises" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 1 can be found <a href="https://colab.research.google.com/drive/1AqVvktGz3LStUyu6dLJFsU2KoqNxgagT?usp=sharing">here</a>.</p>
 
 </div>
 </div>
@@ -421,7 +515,7 @@ <h2><span class="header-section-number">1.8</span> Tips on writing your first co
         </div>
       </div>
 <a href="index.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
-<a href="about-the-authors.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+<a href="working-with-data-structures.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
     </div>
   </div>
 <script src="libs/gitbook-2.6.7/js/app.min.js"></script>
diff --git a/docs/no_toc/01-intro-to-computing.md b/docs/no_toc/01-intro-to-computing.md
index ebcf137..cc8d4ee 100644
--- a/docs/no_toc/01-intro-to-computing.md
+++ b/docs/no_toc/01-intro-to-computing.md
@@ -38,11 +38,13 @@ More importantly: **How we organize ideas \<-\> Instructing a computer to do som
 
 Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user.
 
-Let's open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named "KRAS Demo" in your Google Classroom workspace. If you are taking this course on your own time, open up...
+Let's open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named "KRAS Demo" in your Google Classroom workspace. If you are taking this course on your own time, you can view it [here](https://colab.research.google.com/drive/1_77QQcj0mgZOWLlhtkZ-QKWUP1dnSt-_?usp=sharing).
+
+![](images/colab.png){width="800"}
 
 Today, we will pay close attention to:
 
--   Python Console (Execution): Open it via View -\> Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.
+-   Python Console ("Executions"): Open it via View -\> Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.
 
 -   Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text *and* Python code, and it helps us understand better the code we are writing.
 
@@ -50,7 +52,7 @@ Today, we will pay close attention to:
 
 The first thing we will do is see the different ways we can run Python code. You can do the following:
 
-1.  Type something into the Python Console (Execution) and type enter, such as `2+2`. The Python Console will run it and give you an output.
+1.  Type something into the Python Console (Execution) and click the arrow button, such as `2+2`. The Python Console will run it and give you an output.
 2.  Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data.
 3.  Run every single Python code chunk via Runtime -\> Run all.
 
@@ -66,13 +68,15 @@ Python Notebook is great for data science work, because:
 
 -   It is flexible to use other programming languages, such as R.
 
+The version of Python used in this course and in Google Colab is Python 3, which is the version of Python that is most supported. Some Python software is written in Python 2, which is very similar but has some [notable differences](https://www.fullstackpython.com/python-2-or-3.html).
+
 Now, we will get to the basics of programming grammar.
 
 ## Grammar Structure 1: Evaluation of Expressions
 
 -   **Expressions** are be built out of **operations** or **functions**.
 
--   Functions and operations take in **data types**, do something with them, and return another data type.
+-   Functions and operations take in **data types** as inputs, do something with them, and **return** another data type as ouput.
 
 -   We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it.
 
@@ -142,7 +146,19 @@ add(18, add(21, 65))
 ## 104
 ```
 
-Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to *readable* code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Because the `add()` function isn't typically used, it is not automatically available, so we used the import statement to load it in.)
+Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to *readable* code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Most functions in Python are stored in a collection of functions called **modules** that needs to be loaded. The `import` statement gives us permission to access the functions in the module "operator".)
+
+### Function machine schema
+
+A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:
+
+![Function machine from algebra class.](images/function_machine.png)
+
+Here are some aspects of this schema to pay attention to:
+
+-   A programmer should not need to know how the function or operation is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.
+
+-   A function can have different kinds of inputs and outputs - it doesn't need to be numbers. In the `len()` function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.
 
 ### Data types
 
@@ -155,16 +171,6 @@ Here are some common data types we will be using in this course.
 | String         |           str           | "hello", "234-234-8594" |
 | Boolean        |          bool           |       True, False       |
 
-A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:
-
-![Function machine from algebra class.](images/function_machine.png)
-
-Here are some aspects of this schema to pay attention to:
-
--   A programmer should not need to know how the function is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.
-
--   A function can have different kinds of inputs and outputs - it doesn't need to be numbers. In the `len()` function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.
-
 ## Grammar Structure 2: Storing data types in the Variable Environment
 
 To build up a computer program, we need to store our returned data type from our expression somewhere for downstream use. We can assign a variable to it as follows:
@@ -182,11 +188,11 @@ If you enter this in the Console, you will see that in the Variable Environment,
 >
 > Bind variable to the left of `=` to the resulting value.
 >
-> The variable is stored in the Variable Environment.
+> The variable is stored in the **Variable Environment**.
 
 The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined.
 
-The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. When we work with large datasets, if you assign a variable to a data type larger than the available RAM, it will not work. More on this later.
+The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM.
 
 Look, now `x` can be reused downstream:
 
@@ -203,7 +209,7 @@ x - 2
 y = x * 2
 ```
 
-It is quite common for programmers to not know what data type a variable is while they are coding. To learn about the data type of a variable, use the `type()` function on any variable in Python:
+It is quite common for programmers to have to look up the data type of a variable while they are coding. To learn about the data type of a variable, use the `type()` function on any variable in Python:
 
 
 ``` python
@@ -214,7 +220,7 @@ type(y)
 ## <class 'int'>
 ```
 
-We should give useful variable names so that we know what to expect! Consider `num_sales` instead of `y`.
+We should give useful variable names so that we know what to expect! If you are working with numerical sales data, consider `num_sales` instead of `y`.
 
 ## Grammar Structure 3: Evaluation of Functions
 
@@ -222,22 +228,30 @@ Let's look at functions a little bit more formally: A function has a **function
 
 ### Execution rule for functions:
 
-> Evaluate the function by its arguments, and if the arguments are functions or contains operations, evaluate those functions or operations first.
+> Evaluate the function by its arguments if there's any, and if the arguments are functions or contains operations, evaluate those functions or operations first.
 >
 > The output of functions is called the **returned value**.
 
-Often, we will use multiple functions, in a nested way, or use parenthesis to change the order of operation. Being able to read nested operations, nested functions, and parenthesis is very important. Think about what the Python is going to do step-by--step in the line of code below:
+Often, we will use multiple functions in a nested way, and it is important to understand how the Python console understand the order of operation. We can also use parenthesis to change the order of operation. Think about what the Python is going to do step-by--step in the lines of code below:
+
+
+``` python
+max(len("hello"), 4)
+```
 
+```
+## 5
+```
 
 ``` python
-(len("hello") + 4) * 2
+(len("pumpkin") - 8) * 2
 ```
 
 ```
-## 18
+## -2
 ```
 
-If we don't know how to use a function, such as `pow()` we can ask for help:
+If we don't know how to use a function, such as `pow()`, we can ask for help:
 
 ```         
 ?pow
@@ -249,7 +263,9 @@ Some types, such as ints, are able to use a more efficient algorithm when
 invoked using the three argument form.
 ```
 
-This shows the function takes in three input arguments: `base`, `exp`, and `mod=None`. When an argument has an assigned value of `mod=None`, that means the input argument already has a value, and you don't need to specify anything, unless you want to.
+We can also find a similar help document, in a [nicer rendered form online.](https://docs.python.org/3/library/functions.html#pow) We will practice looking at function documentation throughout the course, because that is a fundamental skill to learn more functions on your own.
+
+The documentation shows the function takes in three input arguments: `base`, `exp`, and `mod=None`. When an argument has an assigned value of `mod=None`, that means the input argument already has a value, and you don't need to specify anything, unless you want to.
 
 The following ways are equivalent ways of using the `pow()` function:
 
@@ -300,13 +316,23 @@ And there is an operational equivalent:
 ## 8
 ```
 
+We will mostly look at functions with input arguments and return types in this course, but not all functions need to have input arguments and output return. Let's look at some examples of functions that don't always have an input or output:
+
+| Function call                                                             | What it takes in         | What it does                                                  | Returns |
+|---------------------------------------------------------------------------|--------------------------|---------------------------------------------------------------|---------|
+| [`pow(a, b)`](https://docs.python.org/3/library/functions.html#pow)       | integer `a`, integer `b` | Raises `a` to the `b`th power.                                | Integer |
+| [`time.sleep(x)`](https://docs.python.org/3/library/time.html#time.sleep) | Integer `x`              | Waits for `x` seconds.                                        | None    |
+| [`dir()`](https://docs.python.org/3/library/functions.html#dir)           | Nothing                  | Gives a list of all the variables defined in the environment. | List    |
+
 ## Tips on writing your first code
 
 `Computer = powerful + stupid`
 
-Even the smallest spelling and formatting changes will cause unexpected output and errors!
+Computers are excellent at doing something specific over and over again, but is extremely rigid and lack flexibility. Here are some tips that is helpful for beginners:
+
+-   Write incrementally, test often.
 
--   Write incrementally, test often
+-   Don't be afraid to break things: it is how we learn how things work in programming.
 
 -   Check your assumptions, especially using new functions, operations, and new data types.
 
@@ -315,3 +341,7 @@ Even the smallest spelling and formatting changes will cause unexpected output a
 -   Ask for help!
 
 To get more familiar with the errors Python gives you, take a look at this [summary of Python error messages](https://betterstack.com/community/guides/scaling-python/python-errors/).
+
+## Exercises
+
+Exercise for week 1 can be found [here](https://colab.research.google.com/drive/1AqVvktGz3LStUyu6dLJFsU2KoqNxgagT?usp=sharing).
diff --git a/docs/no_toc/02-data-structures.md b/docs/no_toc/02-data-structures.md
new file mode 100644
index 0000000..bd24e0d
--- /dev/null
+++ b/docs/no_toc/02-data-structures.md
@@ -0,0 +1,408 @@
+
+
+# Working with data structures
+
+In our second lesson, we start to look at two **data structures**, **Lists** and **Dataframes**, that can handle a large amount of data for analysis.
+
+## Lists
+
+In the first exercise, you started to explore **data structures**, which store information about data types. You explored **lists**, which is an ordered collection of data types or data structures. Each *element* of a list contains a data type or another data structure.
+
+We can now store a vast amount of information in a list, and assign it to a single variable. Even more, we can use operations and functions on a list, modifying many elements within the list at once! This makes analyzing data much more scalable and less repetitive.
+
+We create a list via the bracket `[ ]` operation.
+
+
+``` python
+staff = ["chris", "ted", "jeff"]
+chrNum = [2, 3, 1, 2, 2]
+mixedList = [False, False, False, "A", "B", 92]
+```
+
+### Subsetting lists
+
+To access an element of a list, you can use the bracket notation `[ ]` to access the elements of the list. We simply access an element via the "index" number - the location of the data within the list.
+
+*Here's the tricky thing about the index number: it starts at 0!*
+
+1st element of `chrNum`: `chrNum[0]`
+
+2nd element of `chrNum`: `chrNum[1]`
+
+...
+
+5th element of `chrNum`: `chrNum[4]`
+
+With subsetting, you can modify elements of a list or use the element of a list as part of an expression.
+
+### Subsetting multiple elements of lists
+
+Suppose you want to access multiple elements of a list, such as accessing the first three elements of `chrNum`. You would use the **slice** operator `:`, which specifies:
+
+-   the index number to start
+
+-   the index number to stop, *plus one.*
+
+If you want to access the first three elements of `chrNum`:
+
+
+``` python
+chrNum[0:3]
+```
+
+```
+## [2, 3, 1]
+```
+
+The first element's index number is 0, the third element's index number is 2, plus 1, which is 3.
+
+If you want to access the second and third elements of `chrNum`:
+
+
+``` python
+chrNum[1:3]
+```
+
+```
+## [3, 1]
+```
+
+Another way of accessing the first 3 elements of `chrNum`:
+
+
+``` python
+chrNum[:3]
+```
+
+```
+## [2, 3, 1]
+```
+
+Here, the start index number was not specified. When the start or stop index is *not* specified, it implies that you are subsetting starting the from the beginning of the list or subsetting to the end of the list, respectively. Here's another example, using negative indicies to count from 3 elements from the end of the list:
+
+
+``` python
+chrNum[-3:]
+```
+
+```
+## [1, 2, 2]
+```
+
+You can find more discussion of list slicing, using negative indicies and incremental slicing, [here](https://towardsdatascience.com/the-basics-of-indexing-and-slicing-python-lists-2d12c90a94cf).
+
+## Objects in Python
+
+The list data structure has an organization and functionality that metaphorically represents a pen-and-paper list in our physical world. Like a physical object, we have examined:
+
+-   What does it contain (in terms of data)?
+
+-   What can it do (in terms of functions)?
+
+And if it "makes sense" to us, then it is well-designed.
+
+The list data structure we have been working with is an example of an **Object**. The definition of an object allows us to ask the questions above: *what does it contain, and what can it do?* It is an organizational tool for a collection of data and functions that we can relate to, like a physical object. Formally, an object contains the following:
+
+-   **Value** that holds the essential data for the object.
+
+-   **Attributes** that hold subset or additional data for the object.
+
+-   Functions called **Methods** that are for the object and *have to* take in the variable referenced as an input
+
+This organizing structure on an object applies to pretty much all Python data types and data structures.
+
+Let's see how this applies to the list:
+
+-   **Value**: the contents of the list, such as `[2, 3, 4].`
+
+-   **Attributes** that store additional values: Not relevant for lists.
+
+-   **Methods** that can be used on the object: `chrNum.count(2)` counts the number of instances 2 appears as an element of `chrNum`.
+
+Object methods are functions that does something with the object you are using it on. You should think about `chrNum.count(2)` as a function that takes in `chrNum` and `2` as inputs. If you want to use the count function on list `mixedList`, you would use `mixedList.count(x)`.
+
+Here are some more examples of methods with lists:
+
+| Function method                                                              | What it takes in             | What it does                                                          | Returns                          |
+|---------------|---------------|---------------------------|---------------|
+| [`chrNum.count(x)`](https://docs.python.org/3/tutorial/datastructures.html)  | list `chrNum`, data type `x` | Counts the number of instances `x` appears as an element of `chrNum`. | Integer                          |
+| [`chrNum.append(x)`](https://docs.python.org/3/tutorial/datastructures.html) | list `chrNum`, data type `x` | Appends `x` to the end of the `chrNum`.                               | None (but `chrNum` is modified!) |
+| [`chrNum.sort()`](https://docs.python.org/3/tutorial/datastructures.html)    | list `chrNum`                | Sorts `chrNum` by ascending order.                                    | None (but `chrNum` is modified!) |
+| [`chrNum.reverse()`](https://docs.python.org/3/tutorial/datastructures.html) | list `chrNum`                | Reverses the order of `chrNum`.                                       | None (but `chrNum` is modified!) |
+
+## Methods vs Functions
+
+**Methods** *have to* take in the object of interest as an input: `chrNum.count(2)` automatically treat `chrNum` as an input. Methods are built for a specific Object type.
+
+**Functions** do not have an implied input: `len(chrNum)` requires specifying a list in the input.
+
+Otherwise, there is no strong distinction between the two.
+
+## Dataframes
+
+A Dataframe is a two-dimensional data structure that stores data like a spreadsheet does.
+
+The Dataframe data structure is found within a Python module called "Pandas". A Python module is an organized collection of functions and data structures. The `import` statement below gives us permission to access the "Pandas" module via the variable `pd`.
+
+To load in a Dataframe from existing spreadsheet data, we use the function [`pd.read_csv()`](https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html):
+
+
+``` python
+import pandas as pd
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+type(metadata)
+```
+
+```
+## <class 'pandas.core.frame.DataFrame'>
+```
+
+There is a similar function [`pd.read_excel()`](https://pandas.pydata.org/docs/reference/api/pandas.read_excel.html) for loading in Excel spreadsheets.
+
+Let's investigate the Dataframe as an object:
+
+-   What does a Dataframe contain (values, attributes)?
+
+-   What can a Dataframe do (methods)?
+
+## What does a Dataframe contain?
+
+We first take a look at the contents:
+
+
+``` python
+metadata
+```
+
+```
+##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]
+```
+
+It looks like there are 1864 rows and 30 columns in this Dataframe, and when we display it it shows some of the data.
+
+
+``` python
+metadata
+```
+
+```
+##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]
+```
+
+We can look at specific columns by looking at **attributes** via the dot operation. We can also look at the columns via the bracket operation.
+
+
+``` python
+metadata.ModelID
+```
+
+```
+## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object
+```
+
+``` python
+metadata['ModelID']
+```
+
+```
+## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object
+```
+
+The names of all columns is stored as an attribute, which can be accessed via the dot operation.
+
+
+``` python
+metadata.columns
+```
+
+```
+## Index(['ModelID', 'PatientID', 'CellLineName', 'StrippedCellLineName', 'Age',
+##        'SourceType', 'SangerModelID', 'RRID', 'DepmapModelType', 'AgeCategory',
+##        'GrowthPattern', 'LegacyMolecularSubtype', 'PrimaryOrMetastasis',
+##        'SampleCollectionSite', 'Sex', 'SourceDetail', 'LegacySubSubtype',
+##        'CatalogNumber', 'CCLEName', 'COSMICID', 'PublicComments',
+##        'WTSIMasterCellID', 'EngineeredModel', 'TreatmentStatus',
+##        'OnboardedMedia', 'PlateCoating', 'OncotreeCode', 'OncotreeSubtype',
+##        'OncotreePrimaryDisease', 'OncotreeLineage'],
+##       dtype='object')
+```
+
+The number of rows and columns are also stored as an attribute:
+
+
+``` python
+metadata.shape
+```
+
+```
+## (1864, 30)
+```
+
+## What can a Dataframe do?
+
+We can use the [`.head()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.head.html) and [`.tail()`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.tail.html) methods to look at the first few rows and last few rows of `metadata`, respectively:
+
+
+``` python
+metadata.head()
+```
+
+```
+##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]
+```
+
+``` python
+metadata.tail()
+```
+
+```
+##          ModelID  PatientID  ...          OncotreePrimaryDisease    OncotreeLineage
+## 1859  ACH-002968  PT-pjhrsc  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1860  ACH-002972  PT-dkXZB1  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1861  ACH-002979  PT-lyHTzo  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1862  ACH-002981  PT-Z9akXf  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1863  ACH-003071  PT-LAGmLq  ...       Lung Neuroendocrine Tumor               Lung
+## 
+## [5 rows x 30 columns]
+```
+
+Both of these functions (without input arguments) are considered as **methods**: they are functions that does something with the Dataframe you are using it on. You should think about `metadata.head()` as a function that takes in `metadata` as an input. If we had another Dataframe called `my_data` and you want to use the same function, you will have to say `my_data.head()`.
+
+## Subsetting Dataframes 
+
+Perhaps the most important operation you will can do with Dataframes is subsetting them. There are two ways to do it. The first way is to subset by numerical indicies, exactly like how we did for lists.
+
+You will use the [`iloc`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html) attribute and bracket operations, and you give two slices: one for the row, and one for the column.
+
+Let's start with a small dataframe to see how it works before returning to `metadata`:
+
+
+``` python
+df = pd.DataFrame(data={'status': ["treated", "untreated", "untreated", "discharged", "treated"],
+                            'age_case': [25, 43, 21, 65, 7],
+                            'age_control': [49, 20, 32, 25, 32]})
+df
+```
+
+```
+##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32
+```
+
+Here is how the dataframe looks like with the row and column index numbers:
+
+![](images/pandas_subset_0.png)
+
+Subset the first fourth rows, and the first two columns:
+
+![](images/pandas subset_1.png)
+
+Now, back to `metadata` dataframe:
+
+Subset the first 5 rows, and first two columns:
+
+
+``` python
+metadata.iloc[:5, :2]
+```
+
+```
+##       ModelID  PatientID
+## 0  ACH-000001  PT-gj46wT
+## 1  ACH-000002  PT-5qa3uk
+## 2  ACH-000003  PT-puKIyc
+## 3  ACH-000004  PT-q4K2cp
+## 4  ACH-000005  PT-q4K2cp
+```
+
+If we want a custom slice that is not sequential, we can use an integer list. Subset the last 5 rows, and the 1st and 10 and 21th column:
+
+
+``` python
+metadata.iloc[5:, [1, 10, 21]]
+```
+
+```
+##       PatientID GrowthPattern  WTSIMasterCellID
+## 5     PT-ej13Dz    Suspension            2167.0
+## 6     PT-NOXwpH      Adherent             569.0
+## 7     PT-fp8PeY      Adherent            1806.0
+## 8     PT-puKIyc      Adherent            2104.0
+## 9     PT-AR7W9o      Adherent               NaN
+## ...         ...           ...               ...
+## 1859  PT-pjhrsc      Organoid               NaN
+## 1860  PT-dkXZB1      Organoid               NaN
+## 1861  PT-lyHTzo      Organoid               NaN
+## 1862  PT-Z9akXf      Organoid               NaN
+## 1863  PT-LAGmLq    Suspension               NaN
+## 
+## [1859 rows x 3 columns]
+```
+
+When we subset via numerical indicies, it's called **explicit subsetting**. This is a great way to start thinking about subsetting your dataframes for analysis, but explicit subsetting can lead to some inconsistencies in the long run. For instance, suppose your collaborator added a new cell line to the metadata and changed the order of the column. Then your code to subset the last 5 rows and the columns will get you a different answer once the spreadsheet is changed.
+
+The second way is to subset by the column name and comparison operators, also known as **implicit subsetting**. This is much more robust in data analysis practice. You will learn about it next week!
+
+## Exercises
+
+Exercise for week 2 can be found [here](https://colab.research.google.com/drive/1oIL3gKEZR2Lq16k6XY0HXIhjYl34pEjr?usp=sharing).
diff --git a/docs/no_toc/03-data-wrangling1.md b/docs/no_toc/03-data-wrangling1.md
new file mode 100644
index 0000000..50ee0c1
--- /dev/null
+++ b/docs/no_toc/03-data-wrangling1.md
@@ -0,0 +1,354 @@
+
+
+# Data Wrangling, Part 1
+
+From our first two lessons, we are now equipped with enough fundamental programming skills to apply it to various steps in the data science workflow, which is a natural cycle that occurs in data analysis.
+
+![Data science workflow. Image source: R for Data Science.](https://d33wubrfki0l68.cloudfront.net/571b056757d68e6df81a3e3853f54d3c76ad6efc/32d37/diagrams/data-science.png){width="550"}
+
+For the rest of the course, we focus on *Transform* and *Visualize* with the assumption that our data is in a nice, "Tidy format". First, we need to understand what it means for a data to be "Tidy".
+
+## Tidy Data
+
+Here, we describe a standard of organizing data. It is important to have standards, as it facilitates a consistent way of thinking about data organization and building tools (functions) that make use of that standard. The principles of **tidy data**, developed by Hadley Wickham:
+
+1.  Each variable must have its own column.
+
+2.  Each observation must have its own row.
+
+3.  Each value must have its own cell.
+
+If you want to be technical about what variables and observations are, Hadley Wickham describes:
+
+> A **variable** contains all values that measure the same underlying attribute (like height, temperature, duration) across units. An **observation** contains all values measured on the same unit (like a person, or a day, or a race) across attributes.
+
+![A tidy dataframe. Image source: R for Data Science.](https://r4ds.hadley.nz/images/tidy-1.png){width="800"}
+
+## Our working Tidy Data: DepMap Project
+
+The [Dependency Map project](https://depmap.org/portal/) is a multi-omics profiling of cancer cell lines combined with functional assays such as CRISPR and drug sensitivity to help identify cancer vulnerabilities and drug targets. Here are some of the data that we have public access to. We have been looking at the metadata since last session.
+
+-   Metadata
+
+-   Somatic mutations
+
+-   Gene expression
+
+-   Drug sensitivity
+
+-   CRISPR knockout
+
+-   and more...
+
+Let's load these datasets in, and see how these datasets fit the definition of Tidy data:
+
+
+``` python
+import pandas as pd
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+mutation = pd.read_csv("classroom_data/mutation.csv")
+expression = pd.read_csv("classroom_data/expression.csv")
+```
+
+
+``` python
+metadata.head()
+```
+
+```
+##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]
+```
+
+
+``` python
+mutation.head()
+```
+
+```
+##       ModelID  CACNA1D_Mut  CYP2D6_Mut  ...  CCDC28A_Mut  C1orf194_Mut  U2AF1_Mut
+## 0  ACH-000001        False       False  ...        False         False      False
+## 1  ACH-000002        False       False  ...        False         False      False
+## 2  ACH-000004        False       False  ...        False         False      False
+## 3  ACH-000005        False       False  ...        False         False      False
+## 4  ACH-000006        False       False  ...        False         False      False
+## 
+## [5 rows x 540 columns]
+```
+
+
+``` python
+expression.head()
+```
+
+```
+##       ModelID  ENPP4_Exp  CREBBP_Exp  ...  OR5D13_Exp  C2orf81_Exp  OR8S1_Exp
+## 0  ACH-001113   2.280956    4.094236  ...         0.0     1.726831        0.0
+## 1  ACH-001289   3.622930    3.606442  ...         0.0     0.790772        0.0
+## 2  ACH-001339   0.790772    2.970854  ...         0.0     0.575312        0.0
+## 3  ACH-001538   3.485427    2.801159  ...         0.0     1.077243        0.0
+## 4  ACH-000242   0.879706    3.327687  ...         0.0     0.722466        0.0
+## 
+## [5 rows x 536 columns]
+```
+
+| Dataframe  | The observation is | Some variables are            | Some values are             |
+|-----------------|-----------------|--------------------|------------------|
+| metadata   | Cell line          | ModelID, Age, OncotreeLineage | "ACH-000001", 60, "Myeloid" |
+| expression | Cell line          | KRAS_Exp                      | 2.4, .3                     |
+| mutation   | Cell line          | KRAS_Mut                      | TRUE, FALSE                 |
+
+## Transform: "What do you want to do with this Dataframe"?
+
+Remember that a major theme of the course is about: **How we organize ideas \<-\> Instructing a computer to do something.**
+
+Until now, we haven't focused too much on how we organize our scientific ideas to interact with what we can do with code. Let's pivot to write our code driven by our scientific curiosity. After we are sure that we are working with Tidy data, we can ponder how we want to transform our data that satisfies our scientific question. We will look at several ways we can transform Tidy data, starting with subsetting columns and rows.
+
+Here's a starting prompt:
+
+> In the `metadata` dataframe, which rows would you subset for and columns would you subset for that relate to a scientific question?
+
+We have been using **explicit subsetting** with numerical indicies, such as "I want to filter for rows 20-50 and select columns 2 and 8". We are now going to switch to **implicit subsetting** in which we describe the subsetting criteria via comparision operators and column names, such as:
+
+*"I want to subset for rows such that the OncotreeLineage is breast cancer and subset for columns Age and Sex."*
+
+Notice that when we subset for rows in an implicit way, we formulate our criteria in terms of the columns.This is because we are guaranteed to have column names in Dataframes, but not row names.
+
+#### Let's convert our implicit subsetting criteria into code!
+
+To subset for rows implicitly, we will use the conditional operators on Dataframe columns you used in Exercise 2. To formulate a conditional operator expression that OncotreeLineage is breast cancer:
+
+
+``` python
+metadata['OncotreeLineage'] == "Lung"
+```
+
+```
+## 0       False
+## 1       False
+## 2       False
+## 3       False
+## 4       False
+##         ...  
+## 1859    False
+## 1860    False
+## 1861    False
+## 1862    False
+## 1863     True
+## Name: OncotreeLineage, Length: 1864, dtype: bool
+```
+
+Then, we will use the [`.loc`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html) operation (which is different than [`.iloc`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html) operation!) and subsetting brackets to subset rows and columns Age and Sex at the same time:
+
+
+``` python
+metadata.loc[metadata['OncotreeLineage'] == "Lung", ["Age", "Sex"]]
+```
+
+```
+##        Age     Sex
+## 10    39.0  Female
+## 13    44.0    Male
+## 19    55.0  Female
+## 27    39.0  Female
+## 28    45.0    Male
+## ...    ...     ...
+## 1745  52.0    Male
+## 1819  84.0    Male
+## 1820  57.0  Female
+## 1822  53.0    Male
+## 1863  62.0    Male
+## 
+## [241 rows x 2 columns]
+```
+
+What's going on here? The first component of the subset, `metadata['OncotreeLineage'] == "Lung"`, subsets for the rows. It gives us a column of `True` and `False` values, and we keep rows that correspond to `True` values. Then, we specify the column names we want to subset for via a list.
+
+Here's another example:
+
+
+``` python
+df = pd.DataFrame(data={'status': ["treated", "untreated", "untreated", "discharged", "treated"],
+                            'age_case': [25, 43, 21, 65, 7],
+                            'age_control': [49, 20, 32, 25, 32]})
+                            
+df
+```
+
+```
+##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32
+```
+
+*"I want to subset for rows such that the status is"treated" and subset for columns status and age_case."*
+
+
+``` python
+df.loc[df.status == "treated", ["status", "age_case"]]
+```
+
+```
+##     status  age_case
+## 0  treated        25
+## 4  treated         7
+```
+
+![](images/pandas_subset_2.png)
+
+## Summary Statistics
+
+Now that your Dataframe has be transformed based on your scientific question, you can start doing some analysis on it! A common data science task is to examine summary statistics of a dataset, which summarizes the all the values from a variable in a numeric summary, such as mean, median, or mode.
+
+If we look at the data structure of a Dataframe's column, it is actually not a List, but an object called Series. It has methods can compute summary statistics for us. Let's take a look at a few popular examples:
+
+| Function method                                                                                                           | What it takes in                              | What it does                                                                  | Returns       |
+|----------------|----------------|------------------------|----------------|
+| [`metadata.Age.mean()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.mean.html)                             | `metadata.Age` as a numeric Series            | Computes the mean value of the `Age` column.                                  | Float (NumPy) |
+| [`metadata['Age'].median()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.median.html)                      | `metadata['Age']` as a numeric Series         | Computes the median value of the `Age` column.                                | Float (NumPy) |
+| [`metadata.Age.max()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.max.html)                               | `metadata.Age` as a numeric Series            | Computes the max value of the `Age` column.                                   | Float (NumPy) |
+| [`metadata.OncotreeSubtype.value_counts()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.value_counts.html) | `metadata.OncotreeSubtype` as a string Series | Creates a frequency table of all unique elements in `OncotreeSubtype` column. | Series        |
+
+Let's try it out, with some nice print formatting:
+
+
+``` python
+print("Mean value of Age column:", metadata['Age'].mean())
+```
+
+```
+## Mean value of Age column: 47.45187165775401
+```
+
+``` python
+print("Frequency of column", metadata.OncotreeLineage.value_counts())
+```
+
+```
+## Frequency of column OncotreeLineage
+## Lung                         241
+## Lymphoid                     209
+## CNS/Brain                    123
+## Skin                         118
+## Esophagus/Stomach             95
+## Breast                        92
+## Bowel                         87
+## Head and Neck                 81
+## Myeloid                       77
+## Bone                          75
+## Ovary/Fallopian Tube          74
+## Pancreas                      65
+## Kidney                        64
+## Peripheral Nervous System     55
+## Soft Tissue                   54
+## Uterus                        41
+## Fibroblast                    41
+## Biliary Tract                 40
+## Bladder/Urinary Tract         39
+## Normal                        39
+## Pleura                        35
+## Liver                         28
+## Cervix                        25
+## Eye                           19
+## Thyroid                       18
+## Prostate                      14
+## Vulva/Vagina                   5
+## Ampulla of Vater               4
+## Testis                         4
+## Adrenal Gland                  1
+## Other                          1
+## Name: count, dtype: int64
+```
+
+Notice that the output of some of these methods are Float (NumPy). This refers to a Python Object called NumPy that is extremely popular for scientific computing, but we're not focused on that in this course.)
+
+## Simple data visualization
+
+We will dedicate extensive time later this course to talk about data visualization, but the Dataframe's column, Series, has a method called [`.plot()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.plot.html) that can help us make simple plots for one variable. The `.plot()` method will by default make a line plot, but it is not necessary the plot style we want, so we can give the optional argument `kind` a String value to specify the plot style. We use it for making a histogram or bar plot.
+
+| Plot style | Useful for | kind = | Code                                                         |
+|-------------|-------------|-------------|---------------------------------|
+| Histogram  | Numerics   | "hist" | `metadata.Age.plot(kind = "hist")`                           |
+| Bar plot   | Strings    | "bar"  | `metadata.OncotreeSubtype.value_counts().plot(kind = "bar")` |
+
+Let's look at a histogram:
+
+
+``` python
+import matplotlib.pyplot as plt
+
+plt.figure()
+metadata.Age.plot(kind = "hist")
+plt.show()
+```
+
+<img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png" width="672" />
+
+Let's look at a bar plot:
+
+
+``` python
+plt.figure()
+metadata.OncotreeLineage.value_counts().plot(kind = "bar")
+plt.show()
+```
+
+<img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png" width="672" />
+
+(The `plt.figure()` and `plt.show()` functions are used to render the plots on the website, but you don't need to use it for your exercises. We will discuss this in more detail during our week of data visualization.)
+
+#### Chained function calls
+
+Let's look at our bar plot syntax more carefully. We start with the column `metadata.OncotreeLineage`, and then we first use the method `.value_counts()` to get a *Series* of a frequency table. Then, we take the frequency table Series and use the `.plot()` method.
+
+It is quite common in Python to have multiple "chained" function calls, in which the output of `.value_counts()` is used for the input of `.plot()` all in one line of code. It takes a bit of time to get used to this!
+
+Here's another example of a chained function call, which looks quite complex, but let's break it down:
+
+
+``` python
+plt.figure()
+
+metadata.loc[metadata.AgeCategory == "Adult", ].OncotreeLineage.value_counts().plot(kind="bar")
+
+plt.show()
+```
+
+<img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png" width="672" />
+
+1.  We first take the entire `metadata` and do some subsetting, which outputs a Dataframe.
+2.  We access the `OncotreeLineage` column, which outputs a Series.
+3.  We use the method `.value_counts()`, which outputs a Series.
+4.  We make a plot out of it!
+
+We could have, alternatively, done this in several lines of code:
+
+
+``` python
+plt.figure()
+
+metadata_subset = metadata.loc[metadata.AgeCategory == "Adult", ]
+metadata_subset_lineage = metadata_subset.OncotreeLineage
+lineage_freq = metadata_subset_lineage.value_counts()
+lineage_freq.plot(kind = "bar")
+
+plt.show()
+```
+
+<img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png" width="672" />
+
+These are two different *styles* of code, but they do the exact same thing. It's up to you to decide what is easier for you to understand.
+
+## Exercises
+
+Exercise for week 3 can be found [here](https://colab.research.google.com/drive/1ClNOJviyrcaaoVq5F-YtsO7NhMqn315c?usp=sharing).
diff --git a/docs/no_toc/04-data-wrangling2.md b/docs/no_toc/04-data-wrangling2.md
new file mode 100644
index 0000000..77cb01c
--- /dev/null
+++ b/docs/no_toc/04-data-wrangling2.md
@@ -0,0 +1,334 @@
+
+
+# Data Wrangling, Part 2
+
+We will continue to learn about data analysis with Dataframes. Let's load our three Dataframes from the Depmap project in again:
+
+
+``` python
+import pandas as pd
+import numpy as np
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+mutation = pd.read_csv("classroom_data/mutation.csv")
+expression = pd.read_csv("classroom_data/expression.csv")
+```
+
+## Creating new columns
+
+Often, we want to perform some kind of transformation on our data's columns: perhaps you want to add the values of columns together, or perhaps you want to represent your column in a different scale.
+
+To create a new column, you simply modify it as if it exists using the bracket operation `[ ]`, and the column will be created:
+
+
+``` python
+metadata['AgePlusTen'] = metadata['Age'] + 10
+expression['KRAS_NRAS_exp'] = expression['KRAS_Exp'] + expression['NRAS_Exp']
+expression['log_PIK3CA_Exp'] = np.log(expression['PIK3CA_Exp'])
+```
+
+where [`np.log(x)`](https://numpy.org/doc/stable/reference/generated/numpy.log.html) is a function imported from the module NumPy that takes in a numeric and returns the log-transformed value.
+
+Note: you cannot create a new column referring to the attribute of the Dataframe, such as: `expression.KRAS_Exp_log = np.log(expression.KRAS_Exp)`.
+
+## Merging two Dataframes together
+
+Suppose we have the following Dataframes:
+
+`expression`
+
+| ModelID      | PIK3CA_Exp | log_PIK3CA_Exp |
+|--------------|------------|----------------|
+| "ACH-001113" | 5.138733   | 1.636806       |
+| "ACH-001289" | 3.184280   | 1.158226       |
+| "ACH-001339" | 3.165108   | 1.152187       |
+
+`metadata`
+
+| ModelID      | OncotreeLineage | Age |
+|--------------|-----------------|-----|
+| "ACH-001113" | "Lung"          | 69  |
+| "ACH-001289" | "CNS/Brain"     | NaN |
+| "ACH-001339" | "Skin"          | 14  |
+
+Suppose that I want to compare the relationship between `OncotreeLineage` and `PIK3CA_Exp`, but they are columns in different Dataframes. We want a new Dataframe that looks like this:
+
+| ModelID      | PIK3CA_Exp | log_PIK3CA_Exp | OncotreeLineage | Age |
+|--------------|------------|----------------|-----------------|-----|
+| "ACH-001113" | 5.138733   | 1.636806       | "Lung"          | 69  |
+| "ACH-001289" | 3.184280   | 1.158226       | "CNS/Brain"     | NaN |
+| "ACH-001339" | 3.165108   | 1.152187       | "Skin"          | 14  |
+
+We see that in both dataframes,
+
+-   the rows (observations) represent cell lines.
+
+-   there is a common column `ModelID`, with shared values between the two dataframes that can faciltate the merging process. We call this an **index**.
+
+We will use the method [`.merge()`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html) for Dataframes. It takes a Dataframe to merge with as the required input argument. The method looks for a common index column between the two dataframes and merge based on that index.
+
+
+``` python
+merged = metadata.merge(expression)
+```
+
+It's usually better to specify what that index column to avoid ambiguity, using the `on` optional argument:
+
+
+``` python
+merged = metadata.merge(expression, on='ModelID')
+```
+
+If the index column for the two Dataframes are named differently, you can specify the column name for each Dataframe:
+
+
+``` python
+merged = metadata.merge(expression, left_on='ModelID', right_on='ModelID')
+```
+
+One of the most import checks you should do when merging dataframes is to look at the number of rows and columns before and after merging to see whether it makes sense or not:
+
+The number of rows and columns of `metadata`:
+
+
+``` python
+metadata.shape
+```
+
+```
+## (1864, 31)
+```
+
+The number of rows and columns of `expression`:
+
+
+``` python
+expression.shape
+```
+
+```
+## (1450, 538)
+```
+
+The number of rows and columns of `merged`:
+
+
+``` python
+merged.shape
+```
+
+```
+## (1450, 568)
+```
+
+We see that the number of *columns* in `merged` combines the number of columns in `metadata` and `expression`, while the number of *rows* in `merged` is the smaller of the number of rows in `metadata` and `expression`: it only keeps rows that are found in both Dataframe's index columns. This kind of join is called "inner join", because in the Venn Diagram of elements common in both index column, we keep the inner overlap:
+
+![](images/join.png)
+
+You can specifiy the join style by changing the optional input argument `how`.
+
+-   `how = "outer"` keeps all observations - also known as a "full join"
+
+-   `how = "left"` keeps all observations in the left Dataframe.
+
+-   `how = "right"` keeps all observations in the right Dataframe.
+
+-   `how = "inner"` keeps observations common to both Dataframe. This is the default value of `how`.
+
+## Grouping and summarizing Dataframes
+
+In a dataset, there may be groups of observations that we want to understand, such as case vs. control, or comparing different cancer subtypes. For example, in `metadata`, the observation is cell lines, and perhaps we want to group cell lines into their respective cancer type, `OncotreeLineage`, and look at the mean age for each cancer type.
+
+We want to take `metadata`:
+
+| ModelID      | OncotreeLineage | Age |
+|--------------|-----------------|-----|
+| "ACH-001113" | "Lung"          | 69  |
+| "ACH-001289" | "Lung"          | 23  |
+| "ACH-001339" | "Skin"          | 14  |
+| "ACH-002342" | "Brain"         | 23  |
+| "ACH-004854" | "Brain"         | 56  |
+| "ACH-002921" | "Brain"         | 67  |
+
+into:
+
+| OncotreeLineage | MeanAge |
+|-----------------|---------|
+| "Lung"          | 46      |
+| "Skin"          | 14      |
+| "Brain"         | 48.67   |
+
+To get there, we need to:
+
+-   **Group** the data based on some criteria, elements of `OncotreeLineage`
+
+-   **Summarize** each group via a summary statistic performed on a column, such as `Age`.
+
+We first subset the the two columns we need, and then use the methods [`.group_by(x)`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html) and `.mean()`.
+
+
+``` python
+metadata_grouped = metadata.groupby("OncotreeLineage")
+metadata_grouped['Age'].mean()
+```
+
+```
+## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64
+```
+
+Here's what's going on:
+
+-   We use the Dataframe method [`.group_by(x)`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html) and specify the column we want to group by. The output of this method is a Grouped Dataframe object. It still contains all the information of the `metadata` Dataframe, but it makes a note that it's been grouped.
+
+-   We subset to the column `Age`. The grouping information still persists (This is a Grouped Series object).
+
+-   We use the method `.mean()` to calculate the mean value of `Age` within each group defined by `OncotreeLineage`.
+
+Alternatively, this could have been done in a chain of methods:
+
+
+``` python
+metadata.groupby("OncotreeLineage")["Age"].mean()
+```
+
+```
+## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64
+```
+
+Once a Dataframe has been grouped and a column is selected, all the summary statistics methods you learned from last week, such as `.mean()`, `.median()`, `.max()`, can be used. One new summary statistics method that is useful for this grouping and summarizing analysis is [`.count()`](https://pandas.pydata.org/docs/reference/api/pandas.Series.count.html) which tells you how many entries are counted within each group.
+
+### Optional: Multiple grouping, Multiple columns, Multiple summary statistics
+
+Sometimes, when performing grouping and summary analysis, you want to operate on multiple columns simultaneously.
+
+For example, you may want to group by a combination of `OncotreeLineage` and `AgeCategory`, such as "Lung" and "Adult" as one grouping. You can do so like this:
+
+
+``` python
+metadata_grouped = metadata.groupby(["OncotreeLineage", "AgeCategory"])
+metadata_grouped['Age'].mean()
+```
+
+```
+## OncotreeLineage   AgeCategory
+## Adrenal Gland     Adult          55.000000
+## Ampulla of Vater  Adult          65.500000
+##                   Unknown              NaN
+## Biliary Tract     Adult          58.450000
+##                   Unknown              NaN
+##                                    ...    
+## Thyroid           Unknown              NaN
+## Uterus            Adult          62.060606
+##                   Fetus                NaN
+##                   Unknown              NaN
+## Vulva/Vagina      Adult          75.400000
+## Name: Age, Length: 72, dtype: float64
+```
+
+You can also summarize on multiple columns simultaneously. For each column, you have to specify what summary statistic functions you want to use. This can be specified via the [`.agg(x)`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.agg.html) method on a Grouped Dataframe.
+
+For example, coming back to our age case-control Dataframe,
+
+
+``` python
+df = pd.DataFrame(data={'status': ["treated", "untreated", "untreated", "discharged", "treated"],
+                            'age_case': [25, 43, 21, 65, 7],
+                            'age_control': [49, 20, 32, 25, 32]})
+                            
+df
+```
+
+```
+##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32
+```
+
+We group by `status` and summarize `age_case` and `age_control` with a few summary statistics each:
+
+
+``` python
+df.groupby("status").agg({"age_case": "mean", "age_control": ["min", "max", "mean"]})
+```
+
+```
+##            age_case age_control          
+##                mean         min max  mean
+## status                                   
+## discharged     65.0          25  25  25.0
+## treated        16.0          32  49  40.5
+## untreated      32.0          20  32  26.0
+```
+
+The input argument to the `.agg(x)` method is called a [Dictionary](https://docs.python.org/3/tutorial/datastructures.html#dictionaries), which let's you structure information in a paired relationship. You can learn more about dictionaries here.
+
+## Exercises
+
+Exercise for week 4 can be found [here](https://colab.research.google.com/drive/1ntkUdKQ209vu1M89rcsBst-pKKuwzdwX?usp=sharing).
diff --git a/docs/no_toc/05-data-visualization.md b/docs/no_toc/05-data-visualization.md
new file mode 100644
index 0000000..71d4a68
--- /dev/null
+++ b/docs/no_toc/05-data-visualization.md
@@ -0,0 +1,226 @@
+
+
+# Data Visualization
+
+In our final to last week together, we learn about how to visualize our data.
+
+There are several different data visualization modules in Python:
+
+-   [matplotlib](https://matplotlib.org/) is a general purpose plotting module that is commonly used.
+
+-   [seaborn](https://seaborn.pydata.org/) is a plotting module built on top of matplotlib focused on data science and statistical visualization. We will focus on this module for this course.
+
+-   [plotnine](https://plotnine.org/) is a plotting module based on the grammar of graphics organization of making plots. This is very similar to the R package "ggplot".
+
+To get started, we will consider these most simple and common plots:
+
+Distributions (one variable)
+
+-   Histograms
+
+Relational (between 2 continuous variables)
+
+-   Scatterplots
+
+-   Line plots
+
+Categorical (between 1 categorical and 1 continuous variable)
+
+-   Bar plots
+
+-   Violin plots
+
+[![Image source: Seaborn's overview of plotting functions](https://seaborn.pydata.org/_images/function_overview_8_0.png)](https://seaborn.pydata.org/tutorial/function_overview.html)
+
+Why do we focus on these common plots? Our eyes are better at distinguishing certain visual features more than others. All of these plots are focused on their position to depict data, which gives us the most effective visual scale.
+
+[![Image Source: Visualization Analysis and Design by [Tamara Munzner](https://www.oreilly.com/search?q=author:%22Tamara%20Munzner%22)](https://www.oreilly.com/api/v2/epubs/9781466508910/files/image/fig5-1.png)](https://www.oreilly.com/library/view/visualization-analysis-and/9781466508910/K14708_C005.xhtml)
+
+Let's load in our genomics datasets and start making some plots from them.
+
+
+``` python
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+
+metadata = pd.read_csv("classroom_data/metadata.csv")
+mutation = pd.read_csv("classroom_data/mutation.csv")
+expression = pd.read_csv("classroom_data/expression.csv")
+```
+
+## Distributions (one variable)
+
+To create a histogram, we use the function [`sns.displot()`](https://seaborn.pydata.org/generated/seaborn.displot.html) and we specify the input argument `data` as our dataframe, and the input argument `x` as the column name in a String.
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png" width="480" />
+
+(For the webpage's purpose, assign the plot to a variable `plot`. In practice, you don't need to do that. You can just write `sns.displot(data=metadata, x="Age")`).
+
+A common parameter to consider when making histogram is how big the bins are. You can specify the bin width via `binwidth` argument, or the number of bins via `bins` argument.
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", binwidth = 10)
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png" width="480" />
+
+Our histogram also works for categorical variables, such as "Sex".
+
+
+``` python
+plot = sns.displot(data=metadata, x="Sex")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png" width="480" />
+
+**Conditioning on other variables**
+
+Sometimes, you want to examine a distribution, such as Age, conditional on other variables, such as Age for Female, Age for Male, and Age for Unknown: what is the distribution of age when compared with sex? There are several ways of doing it. First, you could color variables by color, using the `hue` input argument:
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", hue="Sex")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png" width="590" />
+
+It is rather hard to tell the groups apart from the coloring. So, we add a new option that we want to separate each bar category via `multiple="dodge"` input argument:
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", hue="Sex", multiple="dodge")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png" width="590" />
+
+Lastly, an alternative to using colors to display the conditional variable, we could make a subplot for each conditional variable's value via `col="Sex"` or `row="Sex"`:
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", col="Sex")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png" width="1440" />
+
+You can find a lot more details about distributions and histograms in [the Seaborn tutorial](https://seaborn.pydata.org/tutorial/distributions.html).
+
+## Relational (between 2 continuous variables)
+
+To visualize two continuous variables, it is common to use a scatterplot or a lineplot. We use the function [`sns.relplot()`](https://seaborn.pydata.org/generated/seaborn.relplot.html) and we specify the input argument `data` as our dataframe, and the input arguments `x` and `y` as the column names in a String:
+
+
+``` python
+plot = sns.relplot(data=expression, x="KRAS_Exp", y="EGFR_Exp")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png" width="480" />
+
+To conditional on other variables, plotting features are used to distinguish conditional variable values:
+
+-   `hue` (similar to the histogram)
+
+-   `style`
+
+-   `size`
+
+Let's merge `expression` and `metadata` together, so that we can examine KRAS and EGFR relationships conditional on primary vs. metastatic cancer status. Here is the scatterplot with different color:
+
+
+``` python
+expression_metadata = expression.merge(metadata)
+
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", hue="PrimaryOrMetastasis")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png" width="629" />
+
+Here is the scatterplot with different shapes:
+
+
+``` python
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", style="PrimaryOrMetastasis")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png" width="629" />
+
+You can also try plotting with `size=PrimaryOrMetastasis"` if you like. None of these seem pretty effective at distinguishing the two groups, so we will try subplot faceting as we did for the histogram:
+
+
+``` python
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", col="PrimaryOrMetastasis")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png" width="1440" />
+
+You can also conditional on multiple variables by assigning a different variable to the conditioning options:
+
+
+``` python
+plot = sns.relplot(data=expression_metadata, x="KRAS_Exp", y="EGFR_Exp", hue="PrimaryOrMetastasis", col="AgeCategory")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png" width="2069" />
+
+You can find a lot more details about relational plots such as scatterplots and lineplots [in the Seaborn tutorial](https://seaborn.pydata.org/tutorial/relational.html).
+
+## Categorical (between 1 categorical and 1 continuous variable)
+
+A very similar pattern follows for categorical plots. We start with [sns.catplot()](https://seaborn.pydata.org/generated/seaborn.catplot.html) as our main plotting function, with the basic input arguments:
+
+-   `data`
+
+-   `x`
+
+-   `y`
+
+You can change the plot styles via the input arguments:
+
+-   `kind`: "strip", "box", "swarm", etc.
+
+You can add additional conditional variables via the input arguments:
+
+-   `hue`
+
+-   `col`
+
+-   `row`
+
+See categorical plots [in the Seaborn tutorial.](https://seaborn.pydata.org/tutorial/categorical.html)
+
+## Basic plot customization
+
+You can easily change the axis labels and title if you modify the plot object, using the method `.set()`:
+
+
+``` python
+exp_plot = sns.relplot(data=expression, x="KRAS_Exp", y="EGFR_Exp")
+exp_plot.set(xlabel="KRAS Espression", ylabel="EGFR Expression", title="Gene expression relationship")
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png" width="244" /><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png" width="480" />
+
+You can change the color palette by setting adding the `palette` input argument to any of the plots. You can explore available color palettes [here](https://www.practicalpythonfordatascience.com/ap_seaborn_palette):
+
+
+``` python
+plot = sns.displot(data=metadata, x="Age", hue="Sex", multiple="dodge", palette=sns.color_palette(palette='rainbow')
+)
+```
+
+```
+## <string>:1: UserWarning: The palette list has more values (6) than needed (3), which may not be intended.
+```
+
+<img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png" width="590" />
+
+## Exercises
+
+Exercise for week 5 can be found [here](https://colab.research.google.com/drive/1kT3zzq2rrhL1vHl01IdW5L1V7v0iK0wY?usp=sharing).
diff --git a/docs/no_toc/404.html b/docs/no_toc/404.html
index 2c73718..ac6d572 100644
--- a/docs/no_toc/404.html
+++ b/docs/no_toc/404.html
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
diff --git a/docs/no_toc/About.md b/docs/no_toc/About.md
index c307ec3..f902595 100644
--- a/docs/no_toc/About.md
+++ b/docs/no_toc/About.md
@@ -51,7 +51,7 @@ These credits are based on our [course contributors table guidelines](https://ww
 ##  collate  en_US.UTF-8
 ##  ctype    en_US.UTF-8
 ##  tz       Etc/UTC
-##  date     2024-08-07
+##  date     2024-09-26
 ##  pandoc   3.1.1 @ /usr/local/bin/ (via rmarkdown)
 ## 
 ## ─ Packages ───────────────────────────────────────────────────────────────────
diff --git a/docs/no_toc/about-the-authors.html b/docs/no_toc/about-the-authors.html
index 434bafb..1cb928a 100644
--- a/docs/no_toc/about-the-authors.html
+++ b/docs/no_toc/about-the-authors.html
@@ -28,7 +28,7 @@
   <meta name="apple-mobile-web-app-status-bar-style" content="black" />
   
   <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
-<link rel="prev" href="intro-to-computing.html"/>
+<link rel="prev" href="data-visualization.html"/>
 <link rel="next" href="references.html"/>
 <script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -342,7 +386,7 @@ <h1>About the Authors<a href="about-the-authors.html#about-the-authors" class="a
 ##  collate  en_US.UTF-8
 ##  ctype    en_US.UTF-8
 ##  tz       Etc/UTC
-##  date     2024-08-07
+##  date     2024-09-26
 ##  pandoc   3.1.1 @ /usr/local/bin/ (via rmarkdown)
 ## 
 ## ─ Packages ───────────────────────────────────────────────────────────────────
@@ -435,7 +479,7 @@ <h1>About the Authors<a href="about-the-authors.html#about-the-authors" class="a
           </div>
         </div>
       </div>
-<a href="intro-to-computing.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-visualization.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
 <a href="references.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
     </div>
   </div>
diff --git a/docs/no_toc/data-visualization.html b/docs/no_toc/data-visualization.html
new file mode 100644
index 0000000..671f810
--- /dev/null
+++ b/docs/no_toc/data-visualization.html
@@ -0,0 +1,443 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 5 Data Visualization | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 5 Data Visualization | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 5 Data Visualization | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="data-wrangling-part-2.html"/>
+<link rel="next" href="about-the-authors.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="data-visualization" class="section level1 hasAnchor" number="5">
+<h1><span class="header-section-number">Chapter 5</span> Data Visualization<a href="data-visualization.html#data-visualization" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>In our final to last week together, we learn about how to visualize our data.</p>
+<p>There are several different data visualization modules in Python:</p>
+<ul>
+<li><p><a href="https://matplotlib.org/">matplotlib</a> is a general purpose plotting module that is commonly used.</p></li>
+<li><p><a href="https://seaborn.pydata.org/">seaborn</a> is a plotting module built on top of matplotlib focused on data science and statistical visualization. We will focus on this module for this course.</p></li>
+<li><p><a href="https://plotnine.org/">plotnine</a> is a plotting module based on the grammar of graphics organization of making plots. This is very similar to the R package “ggplot”.</p></li>
+</ul>
+<p>To get started, we will consider these most simple and common plots:</p>
+<p>Distributions (one variable)</p>
+<ul>
+<li>Histograms</li>
+</ul>
+<p>Relational (between 2 continuous variables)</p>
+<ul>
+<li><p>Scatterplots</p></li>
+<li><p>Line plots</p></li>
+</ul>
+<p>Categorical (between 1 categorical and 1 continuous variable)</p>
+<ul>
+<li><p>Bar plots</p></li>
+<li><p>Violin plots</p></li>
+</ul>
+<p><a href="https://seaborn.pydata.org/tutorial/function_overview.html"><img src="https://seaborn.pydata.org/_images/function_overview_8_0.png" alt="Image source: Seaborn’s overview of plotting functions" /></a></p>
+<p>Why do we focus on these common plots? Our eyes are better at distinguishing certain visual features more than others. All of these plots are focused on their position to depict data, which gives us the most effective visual scale.</p>
+<p><a href="https://www.oreilly.com/library/view/visualization-analysis-and/9781466508910/K14708_C005.xhtml"><img src="https://www.oreilly.com/api/v2/epubs/9781466508910/files/image/fig5-1.png" alt="Image Source: Visualization Analysis and Design by [Tamara Munzner](https://www.oreilly.com/search?q=author:%22Tamara%20Munzner%22)" /></a></p>
+<p>Let’s load in our genomics datasets and start making some plots from them.</p>
+<div class="sourceCode" id="cb113"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb113-1"><a href="data-visualization.html#cb113-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb113-2"><a href="data-visualization.html#cb113-2" tabindex="-1"></a><span class="im">import</span> seaborn <span class="im">as</span> sns</span>
+<span id="cb113-3"><a href="data-visualization.html#cb113-3" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
+<span id="cb113-4"><a href="data-visualization.html#cb113-4" tabindex="-1"></a></span>
+<span id="cb113-5"><a href="data-visualization.html#cb113-5" tabindex="-1"></a></span>
+<span id="cb113-6"><a href="data-visualization.html#cb113-6" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb113-7"><a href="data-visualization.html#cb113-7" tabindex="-1"></a>mutation <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/mutation.csv&quot;</span>)</span>
+<span id="cb113-8"><a href="data-visualization.html#cb113-8" tabindex="-1"></a>expression <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/expression.csv&quot;</span>)</span></code></pre></div>
+<div id="distributions-one-variable" class="section level2 hasAnchor" number="5.1">
+<h2><span class="header-section-number">5.1</span> Distributions (one variable)<a href="data-visualization.html#distributions-one-variable" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>To create a histogram, we use the function <a href="https://seaborn.pydata.org/generated/seaborn.displot.html"><code>sns.displot()</code></a> and we specify the input argument <code>data</code> as our dataframe, and the input argument <code>x</code> as the column name in a String.</p>
+<div class="sourceCode" id="cb114"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb114-1"><a href="data-visualization.html#cb114-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png" width="480" /></p>
+<p>(For the webpage’s purpose, assign the plot to a variable <code>plot</code>. In practice, you don’t need to do that. You can just write <code>sns.displot(data=metadata, x="Age")</code>).</p>
+<p>A common parameter to consider when making histogram is how big the bins are. You can specify the bin width via <code>binwidth</code> argument, or the number of bins via <code>bins</code> argument.</p>
+<div class="sourceCode" id="cb115"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb115-1"><a href="data-visualization.html#cb115-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, binwidth <span class="op">=</span> <span class="dv">10</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png" width="480" /></p>
+<p>Our histogram also works for categorical variables, such as “Sex”.</p>
+<div class="sourceCode" id="cb116"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb116-1"><a href="data-visualization.html#cb116-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Sex&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png" width="480" /></p>
+<p><strong>Conditioning on other variables</strong></p>
+<p>Sometimes, you want to examine a distribution, such as Age, conditional on other variables, such as Age for Female, Age for Male, and Age for Unknown: what is the distribution of age when compared with sex? There are several ways of doing it. First, you could color variables by color, using the <code>hue</code> input argument:</p>
+<div class="sourceCode" id="cb117"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb117-1"><a href="data-visualization.html#cb117-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, hue<span class="op">=</span><span class="st">&quot;Sex&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png" width="590" /></p>
+<p>It is rather hard to tell the groups apart from the coloring. So, we add a new option that we want to separate each bar category via <code>multiple="dodge"</code> input argument:</p>
+<div class="sourceCode" id="cb118"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb118-1"><a href="data-visualization.html#cb118-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, hue<span class="op">=</span><span class="st">&quot;Sex&quot;</span>, multiple<span class="op">=</span><span class="st">&quot;dodge&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png" width="590" /></p>
+<p>Lastly, an alternative to using colors to display the conditional variable, we could make a subplot for each conditional variable’s value via <code>col="Sex"</code> or <code>row="Sex"</code>:</p>
+<div class="sourceCode" id="cb119"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb119-1"><a href="data-visualization.html#cb119-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, col<span class="op">=</span><span class="st">&quot;Sex&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png" width="1440" /></p>
+<p>You can find a lot more details about distributions and histograms in <a href="https://seaborn.pydata.org/tutorial/distributions.html">the Seaborn tutorial</a>.</p>
+</div>
+<div id="relational-between-2-continuous-variables" class="section level2 hasAnchor" number="5.2">
+<h2><span class="header-section-number">5.2</span> Relational (between 2 continuous variables)<a href="data-visualization.html#relational-between-2-continuous-variables" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>To visualize two continuous variables, it is common to use a scatterplot or a lineplot. We use the function <a href="https://seaborn.pydata.org/generated/seaborn.relplot.html"><code>sns.relplot()</code></a> and we specify the input argument <code>data</code> as our dataframe, and the input arguments <code>x</code> and <code>y</code> as the column names in a String:</p>
+<div class="sourceCode" id="cb120"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb120-1"><a href="data-visualization.html#cb120-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png" width="480" /></p>
+<p>To conditional on other variables, plotting features are used to distinguish conditional variable values:</p>
+<ul>
+<li><p><code>hue</code> (similar to the histogram)</p></li>
+<li><p><code>style</code></p></li>
+<li><p><code>size</code></p></li>
+</ul>
+<p>Let’s merge <code>expression</code> and <code>metadata</code> together, so that we can examine KRAS and EGFR relationships conditional on primary vs. metastatic cancer status. Here is the scatterplot with different color:</p>
+<div class="sourceCode" id="cb121"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb121-1"><a href="data-visualization.html#cb121-1" tabindex="-1"></a>expression_metadata <span class="op">=</span> expression.merge(metadata)</span>
+<span id="cb121-2"><a href="data-visualization.html#cb121-2" tabindex="-1"></a></span>
+<span id="cb121-3"><a href="data-visualization.html#cb121-3" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, hue<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png" width="629" /></p>
+<p>Here is the scatterplot with different shapes:</p>
+<div class="sourceCode" id="cb122"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb122-1"><a href="data-visualization.html#cb122-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, style<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png" width="629" /></p>
+<p>You can also try plotting with <code>size=PrimaryOrMetastasis"</code> if you like. None of these seem pretty effective at distinguishing the two groups, so we will try subplot faceting as we did for the histogram:</p>
+<div class="sourceCode" id="cb123"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb123-1"><a href="data-visualization.html#cb123-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, col<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png" width="1440" /></p>
+<p>You can also conditional on multiple variables by assigning a different variable to the conditioning options:</p>
+<div class="sourceCode" id="cb124"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb124-1"><a href="data-visualization.html#cb124-1" tabindex="-1"></a>plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression_metadata, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>, hue<span class="op">=</span><span class="st">&quot;PrimaryOrMetastasis&quot;</span>, col<span class="op">=</span><span class="st">&quot;AgeCategory&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png" width="2069" /></p>
+<p>You can find a lot more details about relational plots such as scatterplots and lineplots <a href="https://seaborn.pydata.org/tutorial/relational.html">in the Seaborn tutorial</a>.</p>
+</div>
+<div id="categorical-between-1-categorical-and-1-continuous-variable" class="section level2 hasAnchor" number="5.3">
+<h2><span class="header-section-number">5.3</span> Categorical (between 1 categorical and 1 continuous variable)<a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>A very similar pattern follows for categorical plots. We start with <a href="https://seaborn.pydata.org/generated/seaborn.catplot.html">sns.catplot()</a> as our main plotting function, with the basic input arguments:</p>
+<ul>
+<li><p><code>data</code></p></li>
+<li><p><code>x</code></p></li>
+<li><p><code>y</code></p></li>
+</ul>
+<p>You can change the plot styles via the input arguments:</p>
+<ul>
+<li><code>kind</code>: “strip”, “box”, “swarm”, etc.</li>
+</ul>
+<p>You can add additional conditional variables via the input arguments:</p>
+<ul>
+<li><p><code>hue</code></p></li>
+<li><p><code>col</code></p></li>
+<li><p><code>row</code></p></li>
+</ul>
+<p>See categorical plots <a href="https://seaborn.pydata.org/tutorial/categorical.html">in the Seaborn tutorial.</a></p>
+</div>
+<div id="basic-plot-customization" class="section level2 hasAnchor" number="5.4">
+<h2><span class="header-section-number">5.4</span> Basic plot customization<a href="data-visualization.html#basic-plot-customization" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>You can easily change the axis labels and title if you modify the plot object, using the method <code>.set()</code>:</p>
+<div class="sourceCode" id="cb125"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb125-1"><a href="data-visualization.html#cb125-1" tabindex="-1"></a>exp_plot <span class="op">=</span> sns.relplot(data<span class="op">=</span>expression, x<span class="op">=</span><span class="st">&quot;KRAS_Exp&quot;</span>, y<span class="op">=</span><span class="st">&quot;EGFR_Exp&quot;</span>)</span>
+<span id="cb125-2"><a href="data-visualization.html#cb125-2" tabindex="-1"></a>exp_plot.<span class="bu">set</span>(xlabel<span class="op">=</span><span class="st">&quot;KRAS Espression&quot;</span>, ylabel<span class="op">=</span><span class="st">&quot;EGFR Expression&quot;</span>, title<span class="op">=</span><span class="st">&quot;Gene expression relationship&quot;</span>)</span></code></pre></div>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png" width="244" /><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png" width="480" /></p>
+<p>You can change the color palette by setting adding the <code>palette</code> input argument to any of the plots. You can explore available color palettes <a href="https://www.practicalpythonfordatascience.com/ap_seaborn_palette">here</a>:</p>
+<div class="sourceCode" id="cb126"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb126-1"><a href="data-visualization.html#cb126-1" tabindex="-1"></a>plot <span class="op">=</span> sns.displot(data<span class="op">=</span>metadata, x<span class="op">=</span><span class="st">&quot;Age&quot;</span>, hue<span class="op">=</span><span class="st">&quot;Sex&quot;</span>, multiple<span class="op">=</span><span class="st">&quot;dodge&quot;</span>, palette<span class="op">=</span>sns.color_palette(palette<span class="op">=</span><span class="st">&#39;rainbow&#39;</span>)</span>
+<span id="cb126-2"><a href="data-visualization.html#cb126-2" tabindex="-1"></a>)</span></code></pre></div>
+<pre><code>## &lt;string&gt;:1: UserWarning: The palette list has more values (6) than needed (3), which may not be intended.</code></pre>
+<p><img src="resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png" width="590" /></p>
+</div>
+<div id="exercises-4" class="section level2 hasAnchor" number="5.5">
+<h2><span class="header-section-number">5.5</span> Exercises<a href="data-visualization.html#exercises-4" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 5 can be found <a href="https://colab.research.google.com/drive/1kT3zzq2rrhL1vHl01IdW5L1V7v0iK0wY?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="data-wrangling-part-2.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="about-the-authors.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/no_toc/data-wrangling-part-1.html b/docs/no_toc/data-wrangling-part-1.html
new file mode 100644
index 0000000..0ece4cc
--- /dev/null
+++ b/docs/no_toc/data-wrangling-part-1.html
@@ -0,0 +1,655 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 3 Data Wrangling, Part 1 | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 3 Data Wrangling, Part 1 | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 3 Data Wrangling, Part 1 | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="working-with-data-structures.html"/>
+<link rel="next" href="data-wrangling-part-2.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="data-wrangling-part-1" class="section level1 hasAnchor" number="3">
+<h1><span class="header-section-number">Chapter 3</span> Data Wrangling, Part 1<a href="data-wrangling-part-1.html#data-wrangling-part-1" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>From our first two lessons, we are now equipped with enough fundamental programming skills to apply it to various steps in the data science workflow, which is a natural cycle that occurs in data analysis.</p>
+<div class="float">
+<img src="https://d33wubrfki0l68.cloudfront.net/571b056757d68e6df81a3e3853f54d3c76ad6efc/32d37/diagrams/data-science.png" width="550" alt="Data science workflow. Image source: R for Data Science." />
+<div class="figcaption">Data science workflow. Image source: R for Data Science.</div>
+</div>
+<p>For the rest of the course, we focus on <em>Transform</em> and <em>Visualize</em> with the assumption that our data is in a nice, “Tidy format”. First, we need to understand what it means for a data to be “Tidy”.</p>
+<div id="tidy-data" class="section level2 hasAnchor" number="3.1">
+<h2><span class="header-section-number">3.1</span> Tidy Data<a href="data-wrangling-part-1.html#tidy-data" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Here, we describe a standard of organizing data. It is important to have standards, as it facilitates a consistent way of thinking about data organization and building tools (functions) that make use of that standard. The principles of <strong>tidy data</strong>, developed by Hadley Wickham:</p>
+<ol style="list-style-type: decimal">
+<li><p>Each variable must have its own column.</p></li>
+<li><p>Each observation must have its own row.</p></li>
+<li><p>Each value must have its own cell.</p></li>
+</ol>
+<p>If you want to be technical about what variables and observations are, Hadley Wickham describes:</p>
+<blockquote>
+<p>A <strong>variable</strong> contains all values that measure the same underlying attribute (like height, temperature, duration) across units. An <strong>observation</strong> contains all values measured on the same unit (like a person, or a day, or a race) across attributes.</p>
+</blockquote>
+<div class="float">
+<img src="https://r4ds.hadley.nz/images/tidy-1.png" width="800" alt="A tidy dataframe. Image source: R for Data Science." />
+<div class="figcaption">A tidy dataframe. Image source: R for Data Science.</div>
+</div>
+</div>
+<div id="our-working-tidy-data-depmap-project" class="section level2 hasAnchor" number="3.2">
+<h2><span class="header-section-number">3.2</span> Our working Tidy Data: DepMap Project<a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>The <a href="https://depmap.org/portal/">Dependency Map project</a> is a multi-omics profiling of cancer cell lines combined with functional assays such as CRISPR and drug sensitivity to help identify cancer vulnerabilities and drug targets. Here are some of the data that we have public access to. We have been looking at the metadata since last session.</p>
+<ul>
+<li><p>Metadata</p></li>
+<li><p>Somatic mutations</p></li>
+<li><p>Gene expression</p></li>
+<li><p>Drug sensitivity</p></li>
+<li><p>CRISPR knockout</p></li>
+<li><p>and more…</p></li>
+</ul>
+<p>Let’s load these datasets in, and see how these datasets fit the definition of Tidy data:</p>
+<div class="sourceCode" id="cb69"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb69-1"><a href="data-wrangling-part-1.html#cb69-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb69-2"><a href="data-wrangling-part-1.html#cb69-2" tabindex="-1"></a></span>
+<span id="cb69-3"><a href="data-wrangling-part-1.html#cb69-3" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb69-4"><a href="data-wrangling-part-1.html#cb69-4" tabindex="-1"></a>mutation <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/mutation.csv&quot;</span>)</span>
+<span id="cb69-5"><a href="data-wrangling-part-1.html#cb69-5" tabindex="-1"></a>expression <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/expression.csv&quot;</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb70"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb70-1"><a href="data-wrangling-part-1.html#cb70-1" tabindex="-1"></a>metadata.head()</span></code></pre></div>
+<pre><code>##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]</code></pre>
+<div class="sourceCode" id="cb72"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb72-1"><a href="data-wrangling-part-1.html#cb72-1" tabindex="-1"></a>mutation.head()</span></code></pre></div>
+<pre><code>##       ModelID  CACNA1D_Mut  CYP2D6_Mut  ...  CCDC28A_Mut  C1orf194_Mut  U2AF1_Mut
+## 0  ACH-000001        False       False  ...        False         False      False
+## 1  ACH-000002        False       False  ...        False         False      False
+## 2  ACH-000004        False       False  ...        False         False      False
+## 3  ACH-000005        False       False  ...        False         False      False
+## 4  ACH-000006        False       False  ...        False         False      False
+## 
+## [5 rows x 540 columns]</code></pre>
+<div class="sourceCode" id="cb74"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb74-1"><a href="data-wrangling-part-1.html#cb74-1" tabindex="-1"></a>expression.head()</span></code></pre></div>
+<pre><code>##       ModelID  ENPP4_Exp  CREBBP_Exp  ...  OR5D13_Exp  C2orf81_Exp  OR8S1_Exp
+## 0  ACH-001113   2.280956    4.094236  ...         0.0     1.726831        0.0
+## 1  ACH-001289   3.622930    3.606442  ...         0.0     0.790772        0.0
+## 2  ACH-001339   0.790772    2.970854  ...         0.0     0.575312        0.0
+## 3  ACH-001538   3.485427    2.801159  ...         0.0     1.077243        0.0
+## 4  ACH-000242   0.879706    3.327687  ...         0.0     0.722466        0.0
+## 
+## [5 rows x 536 columns]</code></pre>
+<table>
+<colgroup>
+<col width="23%" />
+<col width="23%" />
+<col width="27%" />
+<col width="25%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Dataframe</th>
+<th>The observation is</th>
+<th>Some variables are</th>
+<th>Some values are</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>metadata</td>
+<td>Cell line</td>
+<td>ModelID, Age, OncotreeLineage</td>
+<td>“ACH-000001”, 60, “Myeloid”</td>
+</tr>
+<tr class="even">
+<td>expression</td>
+<td>Cell line</td>
+<td>KRAS_Exp</td>
+<td>2.4, .3</td>
+</tr>
+<tr class="odd">
+<td>mutation</td>
+<td>Cell line</td>
+<td>KRAS_Mut</td>
+<td>TRUE, FALSE</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div id="transform-what-do-you-want-to-do-with-this-dataframe" class="section level2 hasAnchor" number="3.3">
+<h2><span class="header-section-number">3.3</span> Transform: “What do you want to do with this Dataframe”?<a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Remember that a major theme of the course is about: <strong>How we organize ideas &lt;-&gt; Instructing a computer to do something.</strong></p>
+<p>Until now, we haven’t focused too much on how we organize our scientific ideas to interact with what we can do with code. Let’s pivot to write our code driven by our scientific curiosity. After we are sure that we are working with Tidy data, we can ponder how we want to transform our data that satisfies our scientific question. We will look at several ways we can transform Tidy data, starting with subsetting columns and rows.</p>
+<p>Here’s a starting prompt:</p>
+<blockquote>
+<p>In the <code>metadata</code> dataframe, which rows would you subset for and columns would you subset for that relate to a scientific question?</p>
+</blockquote>
+<p>We have been using <strong>explicit subsetting</strong> with numerical indicies, such as “I want to filter for rows 20-50 and select columns 2 and 8”. We are now going to switch to <strong>implicit subsetting</strong> in which we describe the subsetting criteria via comparision operators and column names, such as:</p>
+<p><em>“I want to subset for rows such that the OncotreeLineage is breast cancer and subset for columns Age and Sex.”</em></p>
+<p>Notice that when we subset for rows in an implicit way, we formulate our criteria in terms of the columns.This is because we are guaranteed to have column names in Dataframes, but not row names.</p>
+<div id="lets-convert-our-implicit-subsetting-criteria-into-code" class="section level4 hasAnchor" number="3.3.0.1">
+<h4><span class="header-section-number">3.3.0.1</span> Let’s convert our implicit subsetting criteria into code!<a href="data-wrangling-part-1.html#lets-convert-our-implicit-subsetting-criteria-into-code" class="anchor-section" aria-label="Anchor link to header"></a></h4>
+<p>To subset for rows implicitly, we will use the conditional operators on Dataframe columns you used in Exercise 2. To formulate a conditional operator expression that OncotreeLineage is breast cancer:</p>
+<div class="sourceCode" id="cb76"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb76-1"><a href="data-wrangling-part-1.html#cb76-1" tabindex="-1"></a>metadata[<span class="st">&#39;OncotreeLineage&#39;</span>] <span class="op">==</span> <span class="st">&quot;Lung&quot;</span></span></code></pre></div>
+<pre><code>## 0       False
+## 1       False
+## 2       False
+## 3       False
+## 4       False
+##         ...  
+## 1859    False
+## 1860    False
+## 1861    False
+## 1862    False
+## 1863     True
+## Name: OncotreeLineage, Length: 1864, dtype: bool</code></pre>
+<p>Then, we will use the <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.loc.html"><code>.loc</code></a> operation (which is different than <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.iloc.html"><code>.iloc</code></a> operation!) and subsetting brackets to subset rows and columns Age and Sex at the same time:</p>
+<div class="sourceCode" id="cb78"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb78-1"><a href="data-wrangling-part-1.html#cb78-1" tabindex="-1"></a>metadata.loc[metadata[<span class="st">&#39;OncotreeLineage&#39;</span>] <span class="op">==</span> <span class="st">&quot;Lung&quot;</span>, [<span class="st">&quot;Age&quot;</span>, <span class="st">&quot;Sex&quot;</span>]]</span></code></pre></div>
+<pre><code>##        Age     Sex
+## 10    39.0  Female
+## 13    44.0    Male
+## 19    55.0  Female
+## 27    39.0  Female
+## 28    45.0    Male
+## ...    ...     ...
+## 1745  52.0    Male
+## 1819  84.0    Male
+## 1820  57.0  Female
+## 1822  53.0    Male
+## 1863  62.0    Male
+## 
+## [241 rows x 2 columns]</code></pre>
+<p>What’s going on here? The first component of the subset, <code>metadata['OncotreeLineage'] == "Lung"</code>, subsets for the rows. It gives us a column of <code>True</code> and <code>False</code> values, and we keep rows that correspond to <code>True</code> values. Then, we specify the column names we want to subset for via a list.</p>
+<p>Here’s another example:</p>
+<div class="sourceCode" id="cb80"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb80-1"><a href="data-wrangling-part-1.html#cb80-1" tabindex="-1"></a>df <span class="op">=</span> pd.DataFrame(data<span class="op">=</span>{<span class="st">&#39;status&#39;</span>: [<span class="st">&quot;treated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;discharged&quot;</span>, <span class="st">&quot;treated&quot;</span>],</span>
+<span id="cb80-2"><a href="data-wrangling-part-1.html#cb80-2" tabindex="-1"></a>                            <span class="st">&#39;age_case&#39;</span>: [<span class="dv">25</span>, <span class="dv">43</span>, <span class="dv">21</span>, <span class="dv">65</span>, <span class="dv">7</span>],</span>
+<span id="cb80-3"><a href="data-wrangling-part-1.html#cb80-3" tabindex="-1"></a>                            <span class="st">&#39;age_control&#39;</span>: [<span class="dv">49</span>, <span class="dv">20</span>, <span class="dv">32</span>, <span class="dv">25</span>, <span class="dv">32</span>]})</span>
+<span id="cb80-4"><a href="data-wrangling-part-1.html#cb80-4" tabindex="-1"></a>                            </span>
+<span id="cb80-5"><a href="data-wrangling-part-1.html#cb80-5" tabindex="-1"></a>df</span></code></pre></div>
+<pre><code>##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32</code></pre>
+<p><em>“I want to subset for rows such that the status is”treated” and subset for columns status and age_case.”</em></p>
+<div class="sourceCode" id="cb82"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb82-1"><a href="data-wrangling-part-1.html#cb82-1" tabindex="-1"></a>df.loc[df.status <span class="op">==</span> <span class="st">&quot;treated&quot;</span>, [<span class="st">&quot;status&quot;</span>, <span class="st">&quot;age_case&quot;</span>]]</span></code></pre></div>
+<pre><code>##     status  age_case
+## 0  treated        25
+## 4  treated         7</code></pre>
+<p><img src="images/pandas_subset_2.png" /></p>
+</div>
+</div>
+<div id="summary-statistics" class="section level2 hasAnchor" number="3.4">
+<h2><span class="header-section-number">3.4</span> Summary Statistics<a href="data-wrangling-part-1.html#summary-statistics" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Now that your Dataframe has be transformed based on your scientific question, you can start doing some analysis on it! A common data science task is to examine summary statistics of a dataset, which summarizes the all the values from a variable in a numeric summary, such as mean, median, or mode.</p>
+<p>If we look at the data structure of a Dataframe’s column, it is actually not a List, but an object called Series. It has methods can compute summary statistics for us. Let’s take a look at a few popular examples:</p>
+<table style="width:100%;">
+<colgroup>
+<col width="22%" />
+<col width="22%" />
+<col width="33%" />
+<col width="22%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Function method</th>
+<th>What it takes in</th>
+<th>What it does</th>
+<th>Returns</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.mean.html"><code>metadata.Age.mean()</code></a></td>
+<td><code>metadata.Age</code> as a numeric Series</td>
+<td>Computes the mean value of the <code>Age</code> column.</td>
+<td>Float (NumPy)</td>
+</tr>
+<tr class="even">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.median.html"><code>metadata['Age'].median()</code></a></td>
+<td><code>metadata['Age']</code> as a numeric Series</td>
+<td>Computes the median value of the <code>Age</code> column.</td>
+<td>Float (NumPy)</td>
+</tr>
+<tr class="odd">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.max.html"><code>metadata.Age.max()</code></a></td>
+<td><code>metadata.Age</code> as a numeric Series</td>
+<td>Computes the max value of the <code>Age</code> column.</td>
+<td>Float (NumPy)</td>
+</tr>
+<tr class="even">
+<td><a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.value_counts.html"><code>metadata.OncotreeSubtype.value_counts()</code></a></td>
+<td><code>metadata.OncotreeSubtype</code> as a string Series</td>
+<td>Creates a frequency table of all unique elements in <code>OncotreeSubtype</code> column.</td>
+<td>Series</td>
+</tr>
+</tbody>
+</table>
+<p>Let’s try it out, with some nice print formatting:</p>
+<div class="sourceCode" id="cb84"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb84-1"><a href="data-wrangling-part-1.html#cb84-1" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Mean value of Age column:&quot;</span>, metadata[<span class="st">&#39;Age&#39;</span>].mean())</span></code></pre></div>
+<pre><code>## Mean value of Age column: 47.45187165775401</code></pre>
+<div class="sourceCode" id="cb86"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb86-1"><a href="data-wrangling-part-1.html#cb86-1" tabindex="-1"></a><span class="bu">print</span>(<span class="st">&quot;Frequency of column&quot;</span>, metadata.OncotreeLineage.value_counts())</span></code></pre></div>
+<pre><code>## Frequency of column OncotreeLineage
+## Lung                         241
+## Lymphoid                     209
+## CNS/Brain                    123
+## Skin                         118
+## Esophagus/Stomach             95
+## Breast                        92
+## Bowel                         87
+## Head and Neck                 81
+## Myeloid                       77
+## Bone                          75
+## Ovary/Fallopian Tube          74
+## Pancreas                      65
+## Kidney                        64
+## Peripheral Nervous System     55
+## Soft Tissue                   54
+## Uterus                        41
+## Fibroblast                    41
+## Biliary Tract                 40
+## Bladder/Urinary Tract         39
+## Normal                        39
+## Pleura                        35
+## Liver                         28
+## Cervix                        25
+## Eye                           19
+## Thyroid                       18
+## Prostate                      14
+## Vulva/Vagina                   5
+## Ampulla of Vater               4
+## Testis                         4
+## Adrenal Gland                  1
+## Other                          1
+## Name: count, dtype: int64</code></pre>
+<p>Notice that the output of some of these methods are Float (NumPy). This refers to a Python Object called NumPy that is extremely popular for scientific computing, but we’re not focused on that in this course.)</p>
+</div>
+<div id="simple-data-visualization" class="section level2 hasAnchor" number="3.5">
+<h2><span class="header-section-number">3.5</span> Simple data visualization<a href="data-wrangling-part-1.html#simple-data-visualization" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>We will dedicate extensive time later this course to talk about data visualization, but the Dataframe’s column, Series, has a method called <a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.plot.html"><code>.plot()</code></a> that can help us make simple plots for one variable. The <code>.plot()</code> method will by default make a line plot, but it is not necessary the plot style we want, so we can give the optional argument <code>kind</code> a String value to specify the plot style. We use it for making a histogram or bar plot.</p>
+<table>
+<colgroup>
+<col width="18%" />
+<col width="18%" />
+<col width="18%" />
+<col width="45%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Plot style</th>
+<th>Useful for</th>
+<th>kind =</th>
+<th>Code</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Histogram</td>
+<td>Numerics</td>
+<td>“hist”</td>
+<td><code>metadata.Age.plot(kind = "hist")</code></td>
+</tr>
+<tr class="even">
+<td>Bar plot</td>
+<td>Strings</td>
+<td>“bar”</td>
+<td><code>metadata.OncotreeSubtype.value_counts().plot(kind = "bar")</code></td>
+</tr>
+</tbody>
+</table>
+<p>Let’s look at a histogram:</p>
+<div class="sourceCode" id="cb88"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb88-1"><a href="data-wrangling-part-1.html#cb88-1" tabindex="-1"></a><span class="im">import</span> matplotlib.pyplot <span class="im">as</span> plt</span>
+<span id="cb88-2"><a href="data-wrangling-part-1.html#cb88-2" tabindex="-1"></a></span>
+<span id="cb88-3"><a href="data-wrangling-part-1.html#cb88-3" tabindex="-1"></a>plt.figure()</span>
+<span id="cb88-4"><a href="data-wrangling-part-1.html#cb88-4" tabindex="-1"></a>metadata.Age.plot(kind <span class="op">=</span> <span class="st">&quot;hist&quot;</span>)</span>
+<span id="cb88-5"><a href="data-wrangling-part-1.html#cb88-5" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png" width="672" /></p>
+<p>Let’s look at a bar plot:</p>
+<div class="sourceCode" id="cb89"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb89-1"><a href="data-wrangling-part-1.html#cb89-1" tabindex="-1"></a>plt.figure()</span>
+<span id="cb89-2"><a href="data-wrangling-part-1.html#cb89-2" tabindex="-1"></a>metadata.OncotreeLineage.value_counts().plot(kind <span class="op">=</span> <span class="st">&quot;bar&quot;</span>)</span>
+<span id="cb89-3"><a href="data-wrangling-part-1.html#cb89-3" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png" width="672" /></p>
+<p>(The <code>plt.figure()</code> and <code>plt.show()</code> functions are used to render the plots on the website, but you don’t need to use it for your exercises. We will discuss this in more detail during our week of data visualization.)</p>
+<div id="chained-function-calls" class="section level4 hasAnchor" number="3.5.0.1">
+<h4><span class="header-section-number">3.5.0.1</span> Chained function calls<a href="data-wrangling-part-1.html#chained-function-calls" class="anchor-section" aria-label="Anchor link to header"></a></h4>
+<p>Let’s look at our bar plot syntax more carefully. We start with the column <code>metadata.OncotreeLineage</code>, and then we first use the method <code>.value_counts()</code> to get a <em>Series</em> of a frequency table. Then, we take the frequency table Series and use the <code>.plot()</code> method.</p>
+<p>It is quite common in Python to have multiple “chained” function calls, in which the output of <code>.value_counts()</code> is used for the input of <code>.plot()</code> all in one line of code. It takes a bit of time to get used to this!</p>
+<p>Here’s another example of a chained function call, which looks quite complex, but let’s break it down:</p>
+<div class="sourceCode" id="cb90"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb90-1"><a href="data-wrangling-part-1.html#cb90-1" tabindex="-1"></a>plt.figure()</span>
+<span id="cb90-2"><a href="data-wrangling-part-1.html#cb90-2" tabindex="-1"></a></span>
+<span id="cb90-3"><a href="data-wrangling-part-1.html#cb90-3" tabindex="-1"></a>metadata.loc[metadata.AgeCategory <span class="op">==</span> <span class="st">&quot;Adult&quot;</span>, ].OncotreeLineage.value_counts().plot(kind<span class="op">=</span><span class="st">&quot;bar&quot;</span>)</span>
+<span id="cb90-4"><a href="data-wrangling-part-1.html#cb90-4" tabindex="-1"></a></span>
+<span id="cb90-5"><a href="data-wrangling-part-1.html#cb90-5" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png" width="672" /></p>
+<ol style="list-style-type: decimal">
+<li>We first take the entire <code>metadata</code> and do some subsetting, which outputs a Dataframe.</li>
+<li>We access the <code>OncotreeLineage</code> column, which outputs a Series.</li>
+<li>We use the method <code>.value_counts()</code>, which outputs a Series.</li>
+<li>We make a plot out of it!</li>
+</ol>
+<p>We could have, alternatively, done this in several lines of code:</p>
+<div class="sourceCode" id="cb91"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb91-1"><a href="data-wrangling-part-1.html#cb91-1" tabindex="-1"></a>plt.figure()</span>
+<span id="cb91-2"><a href="data-wrangling-part-1.html#cb91-2" tabindex="-1"></a></span>
+<span id="cb91-3"><a href="data-wrangling-part-1.html#cb91-3" tabindex="-1"></a>metadata_subset <span class="op">=</span> metadata.loc[metadata.AgeCategory <span class="op">==</span> <span class="st">&quot;Adult&quot;</span>, ]</span>
+<span id="cb91-4"><a href="data-wrangling-part-1.html#cb91-4" tabindex="-1"></a>metadata_subset_lineage <span class="op">=</span> metadata_subset.OncotreeLineage</span>
+<span id="cb91-5"><a href="data-wrangling-part-1.html#cb91-5" tabindex="-1"></a>lineage_freq <span class="op">=</span> metadata_subset_lineage.value_counts()</span>
+<span id="cb91-6"><a href="data-wrangling-part-1.html#cb91-6" tabindex="-1"></a>lineage_freq.plot(kind <span class="op">=</span> <span class="st">&quot;bar&quot;</span>)</span>
+<span id="cb91-7"><a href="data-wrangling-part-1.html#cb91-7" tabindex="-1"></a></span>
+<span id="cb91-8"><a href="data-wrangling-part-1.html#cb91-8" tabindex="-1"></a>plt.show()</span></code></pre></div>
+<p><img src="resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png" width="672" /></p>
+<p>These are two different <em>styles</em> of code, but they do the exact same thing. It’s up to you to decide what is easier for you to understand.</p>
+</div>
+</div>
+<div id="exercises-2" class="section level2 hasAnchor" number="3.6">
+<h2><span class="header-section-number">3.6</span> Exercises<a href="data-wrangling-part-1.html#exercises-2" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 3 can be found <a href="https://colab.research.google.com/drive/1ClNOJviyrcaaoVq5F-YtsO7NhMqn315c?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="working-with-data-structures.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-wrangling-part-2.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/no_toc/data-wrangling-part-2.html b/docs/no_toc/data-wrangling-part-2.html
new file mode 100644
index 0000000..3e87bd8
--- /dev/null
+++ b/docs/no_toc/data-wrangling-part-2.html
@@ -0,0 +1,660 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 4 Data Wrangling, Part 2 | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 4 Data Wrangling, Part 2 | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 4 Data Wrangling, Part 2 | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="data-wrangling-part-1.html"/>
+<link rel="next" href="data-visualization.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="data-wrangling-part-2" class="section level1 hasAnchor" number="4">
+<h1><span class="header-section-number">Chapter 4</span> Data Wrangling, Part 2<a href="data-wrangling-part-2.html#data-wrangling-part-2" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>We will continue to learn about data analysis with Dataframes. Let’s load our three Dataframes from the Depmap project in again:</p>
+<div class="sourceCode" id="cb92"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb92-1"><a href="data-wrangling-part-2.html#cb92-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb92-2"><a href="data-wrangling-part-2.html#cb92-2" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb92-3"><a href="data-wrangling-part-2.html#cb92-3" tabindex="-1"></a></span>
+<span id="cb92-4"><a href="data-wrangling-part-2.html#cb92-4" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb92-5"><a href="data-wrangling-part-2.html#cb92-5" tabindex="-1"></a>mutation <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/mutation.csv&quot;</span>)</span>
+<span id="cb92-6"><a href="data-wrangling-part-2.html#cb92-6" tabindex="-1"></a>expression <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/expression.csv&quot;</span>)</span></code></pre></div>
+<div id="creating-new-columns" class="section level2 hasAnchor" number="4.1">
+<h2><span class="header-section-number">4.1</span> Creating new columns<a href="data-wrangling-part-2.html#creating-new-columns" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Often, we want to perform some kind of transformation on our data’s columns: perhaps you want to add the values of columns together, or perhaps you want to represent your column in a different scale.</p>
+<p>To create a new column, you simply modify it as if it exists using the bracket operation <code>[ ]</code>, and the column will be created:</p>
+<div class="sourceCode" id="cb93"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb93-1"><a href="data-wrangling-part-2.html#cb93-1" tabindex="-1"></a>metadata[<span class="st">&#39;AgePlusTen&#39;</span>] <span class="op">=</span> metadata[<span class="st">&#39;Age&#39;</span>] <span class="op">+</span> <span class="dv">10</span></span>
+<span id="cb93-2"><a href="data-wrangling-part-2.html#cb93-2" tabindex="-1"></a>expression[<span class="st">&#39;KRAS_NRAS_exp&#39;</span>] <span class="op">=</span> expression[<span class="st">&#39;KRAS_Exp&#39;</span>] <span class="op">+</span> expression[<span class="st">&#39;NRAS_Exp&#39;</span>]</span>
+<span id="cb93-3"><a href="data-wrangling-part-2.html#cb93-3" tabindex="-1"></a>expression[<span class="st">&#39;log_PIK3CA_Exp&#39;</span>] <span class="op">=</span> np.log(expression[<span class="st">&#39;PIK3CA_Exp&#39;</span>])</span></code></pre></div>
+<p>where <a href="https://numpy.org/doc/stable/reference/generated/numpy.log.html"><code>np.log(x)</code></a> is a function imported from the module NumPy that takes in a numeric and returns the log-transformed value.</p>
+<p>Note: you cannot create a new column referring to the attribute of the Dataframe, such as: <code>expression.KRAS_Exp_log = np.log(expression.KRAS_Exp)</code>.</p>
+</div>
+<div id="merging-two-dataframes-together" class="section level2 hasAnchor" number="4.2">
+<h2><span class="header-section-number">4.2</span> Merging two Dataframes together<a href="data-wrangling-part-2.html#merging-two-dataframes-together" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Suppose we have the following Dataframes:</p>
+<p><code>expression</code></p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>PIK3CA_Exp</th>
+<th>log_PIK3CA_Exp</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>5.138733</td>
+<td>1.636806</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>3.184280</td>
+<td>1.158226</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>3.165108</td>
+<td>1.152187</td>
+</tr>
+</tbody>
+</table>
+<p><code>metadata</code></p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>OncotreeLineage</th>
+<th>Age</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>“Lung”</td>
+<td>69</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>“CNS/Brain”</td>
+<td>NaN</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+</tbody>
+</table>
+<p>Suppose that I want to compare the relationship between <code>OncotreeLineage</code> and <code>PIK3CA_Exp</code>, but they are columns in different Dataframes. We want a new Dataframe that looks like this:</p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>PIK3CA_Exp</th>
+<th>log_PIK3CA_Exp</th>
+<th>OncotreeLineage</th>
+<th>Age</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>5.138733</td>
+<td>1.636806</td>
+<td>“Lung”</td>
+<td>69</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>3.184280</td>
+<td>1.158226</td>
+<td>“CNS/Brain”</td>
+<td>NaN</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>3.165108</td>
+<td>1.152187</td>
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+</tbody>
+</table>
+<p>We see that in both dataframes,</p>
+<ul>
+<li><p>the rows (observations) represent cell lines.</p></li>
+<li><p>there is a common column <code>ModelID</code>, with shared values between the two dataframes that can faciltate the merging process. We call this an <strong>index</strong>.</p></li>
+</ul>
+<p>We will use the method <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.merge.html"><code>.merge()</code></a> for Dataframes. It takes a Dataframe to merge with as the required input argument. The method looks for a common index column between the two dataframes and merge based on that index.</p>
+<div class="sourceCode" id="cb94"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb94-1"><a href="data-wrangling-part-2.html#cb94-1" tabindex="-1"></a>merged <span class="op">=</span> metadata.merge(expression)</span></code></pre></div>
+<p>It’s usually better to specify what that index column to avoid ambiguity, using the <code>on</code> optional argument:</p>
+<div class="sourceCode" id="cb95"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb95-1"><a href="data-wrangling-part-2.html#cb95-1" tabindex="-1"></a>merged <span class="op">=</span> metadata.merge(expression, on<span class="op">=</span><span class="st">&#39;ModelID&#39;</span>)</span></code></pre></div>
+<p>If the index column for the two Dataframes are named differently, you can specify the column name for each Dataframe:</p>
+<div class="sourceCode" id="cb96"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb96-1"><a href="data-wrangling-part-2.html#cb96-1" tabindex="-1"></a>merged <span class="op">=</span> metadata.merge(expression, left_on<span class="op">=</span><span class="st">&#39;ModelID&#39;</span>, right_on<span class="op">=</span><span class="st">&#39;ModelID&#39;</span>)</span></code></pre></div>
+<p>One of the most import checks you should do when merging dataframes is to look at the number of rows and columns before and after merging to see whether it makes sense or not:</p>
+<p>The number of rows and columns of <code>metadata</code>:</p>
+<div class="sourceCode" id="cb97"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb97-1"><a href="data-wrangling-part-2.html#cb97-1" tabindex="-1"></a>metadata.shape</span></code></pre></div>
+<pre><code>## (1864, 31)</code></pre>
+<p>The number of rows and columns of <code>expression</code>:</p>
+<div class="sourceCode" id="cb99"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb99-1"><a href="data-wrangling-part-2.html#cb99-1" tabindex="-1"></a>expression.shape</span></code></pre></div>
+<pre><code>## (1450, 538)</code></pre>
+<p>The number of rows and columns of <code>merged</code>:</p>
+<div class="sourceCode" id="cb101"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb101-1"><a href="data-wrangling-part-2.html#cb101-1" tabindex="-1"></a>merged.shape</span></code></pre></div>
+<pre><code>## (1450, 568)</code></pre>
+<p>We see that the number of <em>columns</em> in <code>merged</code> combines the number of columns in <code>metadata</code> and <code>expression</code>, while the number of <em>rows</em> in <code>merged</code> is the smaller of the number of rows in <code>metadata</code> and <code>expression</code>: it only keeps rows that are found in both Dataframe’s index columns. This kind of join is called “inner join”, because in the Venn Diagram of elements common in both index column, we keep the inner overlap:</p>
+<p><img src="images/join.png" /></p>
+<p>You can specifiy the join style by changing the optional input argument <code>how</code>.</p>
+<ul>
+<li><p><code>how = "outer"</code> keeps all observations - also known as a “full join”</p></li>
+<li><p><code>how = "left"</code> keeps all observations in the left Dataframe.</p></li>
+<li><p><code>how = "right"</code> keeps all observations in the right Dataframe.</p></li>
+<li><p><code>how = "inner"</code> keeps observations common to both Dataframe. This is the default value of <code>how</code>.</p></li>
+</ul>
+</div>
+<div id="grouping-and-summarizing-dataframes" class="section level2 hasAnchor" number="4.3">
+<h2><span class="header-section-number">4.3</span> Grouping and summarizing Dataframes<a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>In a dataset, there may be groups of observations that we want to understand, such as case vs. control, or comparing different cancer subtypes. For example, in <code>metadata</code>, the observation is cell lines, and perhaps we want to group cell lines into their respective cancer type, <code>OncotreeLineage</code>, and look at the mean age for each cancer type.</p>
+<p>We want to take <code>metadata</code>:</p>
+<table>
+<thead>
+<tr class="header">
+<th>ModelID</th>
+<th>OncotreeLineage</th>
+<th>Age</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“ACH-001113”</td>
+<td>“Lung”</td>
+<td>69</td>
+</tr>
+<tr class="even">
+<td>“ACH-001289”</td>
+<td>“Lung”</td>
+<td>23</td>
+</tr>
+<tr class="odd">
+<td>“ACH-001339”</td>
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+<tr class="even">
+<td>“ACH-002342”</td>
+<td>“Brain”</td>
+<td>23</td>
+</tr>
+<tr class="odd">
+<td>“ACH-004854”</td>
+<td>“Brain”</td>
+<td>56</td>
+</tr>
+<tr class="even">
+<td>“ACH-002921”</td>
+<td>“Brain”</td>
+<td>67</td>
+</tr>
+</tbody>
+</table>
+<p>into:</p>
+<table>
+<thead>
+<tr class="header">
+<th>OncotreeLineage</th>
+<th>MeanAge</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>“Lung”</td>
+<td>46</td>
+</tr>
+<tr class="even">
+<td>“Skin”</td>
+<td>14</td>
+</tr>
+<tr class="odd">
+<td>“Brain”</td>
+<td>48.67</td>
+</tr>
+</tbody>
+</table>
+<p>To get there, we need to:</p>
+<ul>
+<li><p><strong>Group</strong> the data based on some criteria, elements of <code>OncotreeLineage</code></p></li>
+<li><p><strong>Summarize</strong> each group via a summary statistic performed on a column, such as <code>Age</code>.</p></li>
+</ul>
+<p>We first subset the the two columns we need, and then use the methods <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html"><code>.group_by(x)</code></a> and <code>.mean()</code>.</p>
+<div class="sourceCode" id="cb103"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb103-1"><a href="data-wrangling-part-2.html#cb103-1" tabindex="-1"></a>metadata_grouped <span class="op">=</span> metadata.groupby(<span class="st">&quot;OncotreeLineage&quot;</span>)</span>
+<span id="cb103-2"><a href="data-wrangling-part-2.html#cb103-2" tabindex="-1"></a>metadata_grouped[<span class="st">&#39;Age&#39;</span>].mean()</span></code></pre></div>
+<pre><code>## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64</code></pre>
+<p>Here’s what’s going on:</p>
+<ul>
+<li><p>We use the Dataframe method <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.groupby.html"><code>.group_by(x)</code></a> and specify the column we want to group by. The output of this method is a Grouped Dataframe object. It still contains all the information of the <code>metadata</code> Dataframe, but it makes a note that it’s been grouped.</p></li>
+<li><p>We subset to the column <code>Age</code>. The grouping information still persists (This is a Grouped Series object).</p></li>
+<li><p>We use the method <code>.mean()</code> to calculate the mean value of <code>Age</code> within each group defined by <code>OncotreeLineage</code>.</p></li>
+</ul>
+<p>Alternatively, this could have been done in a chain of methods:</p>
+<div class="sourceCode" id="cb105"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb105-1"><a href="data-wrangling-part-2.html#cb105-1" tabindex="-1"></a>metadata.groupby(<span class="st">&quot;OncotreeLineage&quot;</span>)[<span class="st">&quot;Age&quot;</span>].mean()</span></code></pre></div>
+<pre><code>## OncotreeLineage
+## Adrenal Gland                55.000000
+## Ampulla of Vater             65.500000
+## Biliary Tract                58.450000
+## Bladder/Urinary Tract        65.166667
+## Bone                         20.854545
+## Bowel                        58.611111
+## Breast                       50.961039
+## CNS/Brain                    43.849057
+## Cervix                       47.136364
+## Esophagus/Stomach            57.855556
+## Eye                          51.100000
+## Fibroblast                   38.194444
+## Head and Neck                60.149254
+## Kidney                       46.193548
+## Liver                        43.928571
+## Lung                         55.444444
+## Lymphoid                     38.916667
+## Myeloid                      38.810811
+## Normal                       52.370370
+## Other                        46.000000
+## Ovary/Fallopian Tube         51.980769
+## Pancreas                     60.226415
+## Peripheral Nervous System     5.480000
+## Pleura                       61.000000
+## Prostate                     61.666667
+## Skin                         49.033708
+## Soft Tissue                  27.500000
+## Testis                       25.000000
+## Thyroid                      63.235294
+## Uterus                       62.060606
+## Vulva/Vagina                 75.400000
+## Name: Age, dtype: float64</code></pre>
+<p>Once a Dataframe has been grouped and a column is selected, all the summary statistics methods you learned from last week, such as <code>.mean()</code>, <code>.median()</code>, <code>.max()</code>, can be used. One new summary statistics method that is useful for this grouping and summarizing analysis is <a href="https://pandas.pydata.org/docs/reference/api/pandas.Series.count.html"><code>.count()</code></a> which tells you how many entries are counted within each group.</p>
+<div id="optional-multiple-grouping-multiple-columns-multiple-summary-statistics" class="section level3 hasAnchor" number="4.3.1">
+<h3><span class="header-section-number">4.3.1</span> Optional: Multiple grouping, Multiple columns, Multiple summary statistics<a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>Sometimes, when performing grouping and summary analysis, you want to operate on multiple columns simultaneously.</p>
+<p>For example, you may want to group by a combination of <code>OncotreeLineage</code> and <code>AgeCategory</code>, such as “Lung” and “Adult” as one grouping. You can do so like this:</p>
+<div class="sourceCode" id="cb107"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb107-1"><a href="data-wrangling-part-2.html#cb107-1" tabindex="-1"></a>metadata_grouped <span class="op">=</span> metadata.groupby([<span class="st">&quot;OncotreeLineage&quot;</span>, <span class="st">&quot;AgeCategory&quot;</span>])</span>
+<span id="cb107-2"><a href="data-wrangling-part-2.html#cb107-2" tabindex="-1"></a>metadata_grouped[<span class="st">&#39;Age&#39;</span>].mean()</span></code></pre></div>
+<pre><code>## OncotreeLineage   AgeCategory
+## Adrenal Gland     Adult          55.000000
+## Ampulla of Vater  Adult          65.500000
+##                   Unknown              NaN
+## Biliary Tract     Adult          58.450000
+##                   Unknown              NaN
+##                                    ...    
+## Thyroid           Unknown              NaN
+## Uterus            Adult          62.060606
+##                   Fetus                NaN
+##                   Unknown              NaN
+## Vulva/Vagina      Adult          75.400000
+## Name: Age, Length: 72, dtype: float64</code></pre>
+<p>You can also summarize on multiple columns simultaneously. For each column, you have to specify what summary statistic functions you want to use. This can be specified via the <a href="https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.agg.html"><code>.agg(x)</code></a> method on a Grouped Dataframe.</p>
+<p>For example, coming back to our age case-control Dataframe,</p>
+<div class="sourceCode" id="cb109"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb109-1"><a href="data-wrangling-part-2.html#cb109-1" tabindex="-1"></a>df <span class="op">=</span> pd.DataFrame(data<span class="op">=</span>{<span class="st">&#39;status&#39;</span>: [<span class="st">&quot;treated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;discharged&quot;</span>, <span class="st">&quot;treated&quot;</span>],</span>
+<span id="cb109-2"><a href="data-wrangling-part-2.html#cb109-2" tabindex="-1"></a>                            <span class="st">&#39;age_case&#39;</span>: [<span class="dv">25</span>, <span class="dv">43</span>, <span class="dv">21</span>, <span class="dv">65</span>, <span class="dv">7</span>],</span>
+<span id="cb109-3"><a href="data-wrangling-part-2.html#cb109-3" tabindex="-1"></a>                            <span class="st">&#39;age_control&#39;</span>: [<span class="dv">49</span>, <span class="dv">20</span>, <span class="dv">32</span>, <span class="dv">25</span>, <span class="dv">32</span>]})</span>
+<span id="cb109-4"><a href="data-wrangling-part-2.html#cb109-4" tabindex="-1"></a>                            </span>
+<span id="cb109-5"><a href="data-wrangling-part-2.html#cb109-5" tabindex="-1"></a>df</span></code></pre></div>
+<pre><code>##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32</code></pre>
+<p>We group by <code>status</code> and summarize <code>age_case</code> and <code>age_control</code> with a few summary statistics each:</p>
+<div class="sourceCode" id="cb111"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb111-1"><a href="data-wrangling-part-2.html#cb111-1" tabindex="-1"></a>df.groupby(<span class="st">&quot;status&quot;</span>).agg({<span class="st">&quot;age_case&quot;</span>: <span class="st">&quot;mean&quot;</span>, <span class="st">&quot;age_control&quot;</span>: [<span class="st">&quot;min&quot;</span>, <span class="st">&quot;max&quot;</span>, <span class="st">&quot;mean&quot;</span>]})</span></code></pre></div>
+<pre><code>##            age_case age_control          
+##                mean         min max  mean
+## status                                   
+## discharged     65.0          25  25  25.0
+## treated        16.0          32  49  40.5
+## untreated      32.0          20  32  26.0</code></pre>
+<p>The input argument to the <code>.agg(x)</code> method is called a <a href="https://docs.python.org/3/tutorial/datastructures.html#dictionaries">Dictionary</a>, which let’s you structure information in a paired relationship. You can learn more about dictionaries here.</p>
+</div>
+</div>
+<div id="exercises-3" class="section level2 hasAnchor" number="4.4">
+<h2><span class="header-section-number">4.4</span> Exercises<a href="data-wrangling-part-2.html#exercises-3" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 4 can be found <a href="https://colab.research.google.com/drive/1ntkUdKQ209vu1M89rcsBst-pKKuwzdwX?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="data-wrangling-part-1.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-visualization.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/no_toc/images/colab.png b/docs/no_toc/images/colab.png
new file mode 100644
index 0000000..ccd9004
Binary files /dev/null and b/docs/no_toc/images/colab.png differ
diff --git a/docs/no_toc/images/join.png b/docs/no_toc/images/join.png
new file mode 100644
index 0000000..d408d6b
Binary files /dev/null and b/docs/no_toc/images/join.png differ
diff --git a/docs/no_toc/images/pandas subset_1.png b/docs/no_toc/images/pandas subset_1.png
new file mode 100644
index 0000000..45376f2
Binary files /dev/null and b/docs/no_toc/images/pandas subset_1.png differ
diff --git a/docs/no_toc/images/pandas_subset_0.png b/docs/no_toc/images/pandas_subset_0.png
new file mode 100644
index 0000000..2a37d28
Binary files /dev/null and b/docs/no_toc/images/pandas_subset_0.png differ
diff --git a/docs/no_toc/images/pandas_subset_1.png b/docs/no_toc/images/pandas_subset_1.png
new file mode 100644
index 0000000..0a491f5
Binary files /dev/null and b/docs/no_toc/images/pandas_subset_1.png differ
diff --git a/docs/no_toc/images/pandas_subset_2.png b/docs/no_toc/images/pandas_subset_2.png
new file mode 100644
index 0000000..eecc68e
Binary files /dev/null and b/docs/no_toc/images/pandas_subset_2.png differ
diff --git a/docs/no_toc/index.html b/docs/no_toc/index.html
index 9e6b078..8204dc7 100644
--- a/docs/no_toc/index.html
+++ b/docs/no_toc/index.html
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -202,7 +246,7 @@ <h1>
 </div>
 <div id="header">
 <h1 class="title">Introduction to Python</h1>
-<p class="date"><em>August, 2024</em></p>
+<p class="date"><em>September, 2024</em></p>
 </div>
 <div id="about-this-course" class="section level1 unnumbered hasAnchor">
 <h1>About this Course<a href="index.html#about-this-course" class="anchor-section" aria-label="Anchor link to header"></a></h1>
diff --git a/docs/no_toc/index.md b/docs/no_toc/index.md
index bdb6e62..c4161aa 100644
--- a/docs/no_toc/index.md
+++ b/docs/no_toc/index.md
@@ -1,6 +1,6 @@
 ---
 title: "Introduction to Python"
-date: "August, 2024"
+date: "September, 2024"
 site: bookdown::bookdown_site
 documentclass: book
 bibliography: [book.bib]
diff --git a/docs/no_toc/intro-to-computing.html b/docs/no_toc/intro-to-computing.html
index dcc75b6..6d0ee0a 100644
--- a/docs/no_toc/intro-to-computing.html
+++ b/docs/no_toc/intro-to-computing.html
@@ -29,7 +29,7 @@
   
   <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
 <link rel="prev" href="index.html"/>
-<link rel="next" href="about-the-authors.html"/>
+<link rel="next" href="working-with-data-structures.html"/>
 <script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
 <link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -236,16 +280,17 @@ <h2><span class="header-section-number">1.3</span> A programming language has fo
 <div id="google-colab-setup" class="section level2 hasAnchor" number="1.4">
 <h2><span class="header-section-number">1.4</span> Google Colab Setup<a href="intro-to-computing.html#google-colab-setup" class="anchor-section" aria-label="Anchor link to header"></a></h2>
 <p>Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user.</p>
-<p>Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, open up…</p>
+<p>Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, you can view it <a href="https://colab.research.google.com/drive/1_77QQcj0mgZOWLlhtkZ-QKWUP1dnSt-_?usp=sharing">here</a>.</p>
+<p><img src="images/colab.png" width="800" /></p>
 <p>Today, we will pay close attention to:</p>
 <ul>
-<li><p>Python Console (Execution): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.</p></li>
+<li><p>Python Console (“Executions”): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you.</p></li>
 <li><p>Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text <em>and</em> Python code, and it helps us understand better the code we are writing.</p></li>
 <li><p>Variable Environment: Open it by clicking on the “{x}” button on the left-hand panel. Often, your code will store information in the Variable Environment, so that information can be reused. For instance, we often load in data and store it in the Variable Environment, and use it throughout rest of your Python code.</p></li>
 </ul>
 <p>The first thing we will do is see the different ways we can run Python code. You can do the following:</p>
 <ol style="list-style-type: decimal">
-<li>Type something into the Python Console (Execution) and type enter, such as <code>2+2</code>. The Python Console will run it and give you an output.</li>
+<li>Type something into the Python Console (Execution) and click the arrow button, such as <code>2+2</code>. The Python Console will run it and give you an output.</li>
 <li>Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data.</li>
 <li>Run every single Python code chunk via Runtime -&gt; Run all.</li>
 </ol>
@@ -257,13 +302,14 @@ <h2><span class="header-section-number">1.4</span> Google Colab Setup<a href="in
 <li><p>It encourages excellent documentation, as you can have code, output from code, and prose combined together.</p></li>
 <li><p>It is flexible to use other programming languages, such as R.</p></li>
 </ul>
+<p>The version of Python used in this course and in Google Colab is Python 3, which is the version of Python that is most supported. Some Python software is written in Python 2, which is very similar but has some <a href="https://www.fullstackpython.com/python-2-or-3.html">notable differences</a>.</p>
 <p>Now, we will get to the basics of programming grammar.</p>
 </div>
 <div id="grammar-structure-1-evaluation-of-expressions" class="section level2 hasAnchor" number="1.5">
 <h2><span class="header-section-number">1.5</span> Grammar Structure 1: Evaluation of Expressions<a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions" class="anchor-section" aria-label="Anchor link to header"></a></h2>
 <ul>
 <li><p><strong>Expressions</strong> are be built out of <strong>operations</strong> or <strong>functions</strong>.</p></li>
-<li><p>Functions and operations take in <strong>data types</strong>, do something with them, and return another data type.</p></li>
+<li><p>Functions and operations take in <strong>data types</strong> as inputs, do something with them, and <strong>return</strong> another data type as ouput.</p></li>
 <li><p>We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it.</p></li>
 </ul>
 <p>For instance, consider the following expressions entered to the Python Console:</p>
@@ -285,9 +331,22 @@ <h2><span class="header-section-number">1.5</span> Grammar Structure 1: Evaluati
 <pre><code>## 39</code></pre>
 <div class="sourceCode" id="cb13"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb13-1"><a href="intro-to-computing.html#cb13-1" tabindex="-1"></a>add(<span class="dv">18</span>, add(<span class="dv">21</span>, <span class="dv">65</span>))</span></code></pre></div>
 <pre><code>## 104</code></pre>
-<p>Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to <em>readable</em> code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Because the <code>add()</code> function isn’t typically used, it is not automatically available, so we used the import statement to load it in.)</p>
-<div id="data-types" class="section level3 hasAnchor" number="1.5.1">
-<h3><span class="header-section-number">1.5.1</span> Data types<a href="intro-to-computing.html#data-types" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to <em>readable</em> code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Most functions in Python are stored in a collection of functions called <strong>modules</strong> that needs to be loaded. The <code>import</code> statement gives us permission to access the functions in the module “operator”.)</p>
+<div id="function-machine-schema" class="section level3 hasAnchor" number="1.5.1">
+<h3><span class="header-section-number">1.5.1</span> Function machine schema<a href="intro-to-computing.html#function-machine-schema" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:</p>
+<div class="float">
+<img src="images/function_machine.png" alt="Function machine from algebra class." />
+<div class="figcaption">Function machine from algebra class.</div>
+</div>
+<p>Here are some aspects of this schema to pay attention to:</p>
+<ul>
+<li><p>A programmer should not need to know how the function or operation is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.</p></li>
+<li><p>A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the <code>len()</code> function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.</p></li>
+</ul>
+</div>
+<div id="data-types" class="section level3 hasAnchor" number="1.5.2">
+<h3><span class="header-section-number">1.5.2</span> Data types<a href="intro-to-computing.html#data-types" class="anchor-section" aria-label="Anchor link to header"></a></h3>
 <p>Here are some common data types we will be using in this course.</p>
 <table>
 <thead>
@@ -320,16 +379,6 @@ <h3><span class="header-section-number">1.5.1</span> Data types<a href="intro-to
 </tr>
 </tbody>
 </table>
-<p>A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class:</p>
-<div class="float">
-<img src="images/function_machine.png" alt="Function machine from algebra class." />
-<div class="figcaption">Function machine from algebra class.</div>
-</div>
-<p>Here are some aspects of this schema to pay attention to:</p>
-<ul>
-<li><p>A programmer should not need to know how the function is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language.</p></li>
-<li><p>A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the <code>len()</code> function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs.</p></li>
-</ul>
 </div>
 </div>
 <div id="grammar-structure-2-storing-data-types-in-the-variable-environment" class="section level2 hasAnchor" number="1.6">
@@ -342,18 +391,18 @@ <h3><span class="header-section-number">1.6.1</span> Execution rule for variable
 <blockquote>
 <p>Evaluate the expression to the right of <code>=</code>.</p>
 <p>Bind variable to the left of <code>=</code> to the resulting value.</p>
-<p>The variable is stored in the Variable Environment.</p>
+<p>The variable is stored in the <strong>Variable Environment</strong>.</p>
 </blockquote>
 <p>The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined.</p>
-<p>The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. When we work with large datasets, if you assign a variable to a data type larger than the available RAM, it will not work. More on this later.</p>
+<p>The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM.</p>
 <p>Look, now <code>x</code> can be reused downstream:</p>
 <div class="sourceCode" id="cb16"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb16-1"><a href="intro-to-computing.html#cb16-1" tabindex="-1"></a>x <span class="op">-</span> <span class="dv">2</span></span></code></pre></div>
 <pre><code>## 37</code></pre>
 <div class="sourceCode" id="cb18"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb18-1"><a href="intro-to-computing.html#cb18-1" tabindex="-1"></a>y <span class="op">=</span> x <span class="op">*</span> <span class="dv">2</span></span></code></pre></div>
-<p>It is quite common for programmers to not know what data type a variable is while they are coding. To learn about the data type of a variable, use the <code>type()</code> function on any variable in Python:</p>
+<p>It is quite common for programmers to have to look up the data type of a variable while they are coding. To learn about the data type of a variable, use the <code>type()</code> function on any variable in Python:</p>
 <div class="sourceCode" id="cb19"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb19-1"><a href="intro-to-computing.html#cb19-1" tabindex="-1"></a><span class="bu">type</span>(y)</span></code></pre></div>
 <pre><code>## &lt;class &#39;int&#39;&gt;</code></pre>
-<p>We should give useful variable names so that we know what to expect! Consider <code>num_sales</code> instead of <code>y</code>.</p>
+<p>We should give useful variable names so that we know what to expect! If you are working with numerical sales data, consider <code>num_sales</code> instead of <code>y</code>.</p>
 </div>
 </div>
 <div id="grammar-structure-3-evaluation-of-functions" class="section level2 hasAnchor" number="1.7">
@@ -362,13 +411,15 @@ <h2><span class="header-section-number">1.7</span> Grammar Structure 3: Evaluati
 <div id="execution-rule-for-functions" class="section level3 hasAnchor" number="1.7.1">
 <h3><span class="header-section-number">1.7.1</span> Execution rule for functions:<a href="intro-to-computing.html#execution-rule-for-functions" class="anchor-section" aria-label="Anchor link to header"></a></h3>
 <blockquote>
-<p>Evaluate the function by its arguments, and if the arguments are functions or contains operations, evaluate those functions or operations first.</p>
+<p>Evaluate the function by its arguments if there’s any, and if the arguments are functions or contains operations, evaluate those functions or operations first.</p>
 <p>The output of functions is called the <strong>returned value</strong>.</p>
 </blockquote>
-<p>Often, we will use multiple functions, in a nested way, or use parenthesis to change the order of operation. Being able to read nested operations, nested functions, and parenthesis is very important. Think about what the Python is going to do step-by–step in the line of code below:</p>
-<div class="sourceCode" id="cb21"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb21-1"><a href="intro-to-computing.html#cb21-1" tabindex="-1"></a>(<span class="bu">len</span>(<span class="st">&quot;hello&quot;</span>) <span class="op">+</span> <span class="dv">4</span>) <span class="op">*</span> <span class="dv">2</span></span></code></pre></div>
-<pre><code>## 18</code></pre>
-<p>If we don’t know how to use a function, such as <code>pow()</code> we can ask for help:</p>
+<p>Often, we will use multiple functions in a nested way, and it is important to understand how the Python console understand the order of operation. We can also use parenthesis to change the order of operation. Think about what the Python is going to do step-by–step in the lines of code below:</p>
+<div class="sourceCode" id="cb21"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb21-1"><a href="intro-to-computing.html#cb21-1" tabindex="-1"></a><span class="bu">max</span>(<span class="bu">len</span>(<span class="st">&quot;hello&quot;</span>), <span class="dv">4</span>)</span></code></pre></div>
+<pre><code>## 5</code></pre>
+<div class="sourceCode" id="cb23"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb23-1"><a href="intro-to-computing.html#cb23-1" tabindex="-1"></a>(<span class="bu">len</span>(<span class="st">&quot;pumpkin&quot;</span>) <span class="op">-</span> <span class="dv">8</span>) <span class="op">*</span> <span class="dv">2</span></span></code></pre></div>
+<pre><code>## -2</code></pre>
+<p>If we don’t know how to use a function, such as <code>pow()</code>, we can ask for help:</p>
 <pre><code>?pow
 
 pow(base, exp, mod=None)
@@ -376,33 +427,76 @@ <h3><span class="header-section-number">1.7.1</span> Execution rule for function
  
 Some types, such as ints, are able to use a more efficient algorithm when
 invoked using the three argument form.</code></pre>
-<p>This shows the function takes in three input arguments: <code>base</code>, <code>exp</code>, and <code>mod=None</code>. When an argument has an assigned value of <code>mod=None</code>, that means the input argument already has a value, and you don’t need to specify anything, unless you want to.</p>
+<p>We can also find a similar help document, in a <a href="https://docs.python.org/3/library/functions.html#pow">nicer rendered form online.</a> We will practice looking at function documentation throughout the course, because that is a fundamental skill to learn more functions on your own.</p>
+<p>The documentation shows the function takes in three input arguments: <code>base</code>, <code>exp</code>, and <code>mod=None</code>. When an argument has an assigned value of <code>mod=None</code>, that means the input argument already has a value, and you don’t need to specify anything, unless you want to.</p>
 <p>The following ways are equivalent ways of using the <code>pow()</code> function:</p>
-<div class="sourceCode" id="cb24"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb24-1"><a href="intro-to-computing.html#cb24-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">2</span>, <span class="dv">3</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb26"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb26-1"><a href="intro-to-computing.html#cb26-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">2</span>, <span class="dv">3</span>)</span></code></pre></div>
 <pre><code>## 8</code></pre>
-<div class="sourceCode" id="cb26"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb26-1"><a href="intro-to-computing.html#cb26-1" tabindex="-1"></a><span class="bu">pow</span>(base<span class="op">=</span><span class="dv">2</span>, exp<span class="op">=</span><span class="dv">3</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb28"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb28-1"><a href="intro-to-computing.html#cb28-1" tabindex="-1"></a><span class="bu">pow</span>(base<span class="op">=</span><span class="dv">2</span>, exp<span class="op">=</span><span class="dv">3</span>)</span></code></pre></div>
 <pre><code>## 8</code></pre>
-<div class="sourceCode" id="cb28"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb28-1"><a href="intro-to-computing.html#cb28-1" tabindex="-1"></a><span class="bu">pow</span>(exp<span class="op">=</span><span class="dv">3</span>, base<span class="op">=</span><span class="dv">2</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb30"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb30-1"><a href="intro-to-computing.html#cb30-1" tabindex="-1"></a><span class="bu">pow</span>(exp<span class="op">=</span><span class="dv">3</span>, base<span class="op">=</span><span class="dv">2</span>)</span></code></pre></div>
 <pre><code>## 8</code></pre>
 <p>but this will give you something different:</p>
-<div class="sourceCode" id="cb30"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb30-1"><a href="intro-to-computing.html#cb30-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">3</span>, <span class="dv">2</span>)</span></code></pre></div>
+<div class="sourceCode" id="cb32"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb32-1"><a href="intro-to-computing.html#cb32-1" tabindex="-1"></a><span class="bu">pow</span>(<span class="dv">3</span>, <span class="dv">2</span>)</span></code></pre></div>
 <pre><code>## 9</code></pre>
 <p>And there is an operational equivalent:</p>
-<div class="sourceCode" id="cb32"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb32-1"><a href="intro-to-computing.html#cb32-1" tabindex="-1"></a><span class="dv">2</span> <span class="op">**</span> <span class="dv">3</span></span></code></pre></div>
+<div class="sourceCode" id="cb34"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb34-1"><a href="intro-to-computing.html#cb34-1" tabindex="-1"></a><span class="dv">2</span> <span class="op">**</span> <span class="dv">3</span></span></code></pre></div>
 <pre><code>## 8</code></pre>
+<p>We will mostly look at functions with input arguments and return types in this course, but not all functions need to have input arguments and output return. Let’s look at some examples of functions that don’t always have an input or output:</p>
+<table>
+<colgroup>
+<col width="43%" />
+<col width="15%" />
+<col width="36%" />
+<col width="5%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Function call</th>
+<th>What it takes in</th>
+<th>What it does</th>
+<th>Returns</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/library/functions.html#pow"><code>pow(a, b)</code></a></td>
+<td>integer <code>a</code>, integer <code>b</code></td>
+<td>Raises <code>a</code> to the <code>b</code>th power.</td>
+<td>Integer</td>
+</tr>
+<tr class="even">
+<td><a href="https://docs.python.org/3/library/time.html#time.sleep"><code>time.sleep(x)</code></a></td>
+<td>Integer <code>x</code></td>
+<td>Waits for <code>x</code> seconds.</td>
+<td>None</td>
+</tr>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/library/functions.html#dir"><code>dir()</code></a></td>
+<td>Nothing</td>
+<td>Gives a list of all the variables defined in the environment.</td>
+<td>List</td>
+</tr>
+</tbody>
+</table>
 </div>
 </div>
 <div id="tips-on-writing-your-first-code" class="section level2 hasAnchor" number="1.8">
 <h2><span class="header-section-number">1.8</span> Tips on writing your first code<a href="intro-to-computing.html#tips-on-writing-your-first-code" class="anchor-section" aria-label="Anchor link to header"></a></h2>
 <p><code>Computer = powerful + stupid</code></p>
-<p>Even the smallest spelling and formatting changes will cause unexpected output and errors!</p>
+<p>Computers are excellent at doing something specific over and over again, but is extremely rigid and lack flexibility. Here are some tips that is helpful for beginners:</p>
 <ul>
-<li><p>Write incrementally, test often</p></li>
+<li><p>Write incrementally, test often.</p></li>
+<li><p>Don’t be afraid to break things: it is how we learn how things work in programming.</p></li>
 <li><p>Check your assumptions, especially using new functions, operations, and new data types.</p></li>
 <li><p>Live environments are great for testing, but not great for reproducibility.</p></li>
 <li><p>Ask for help!</p></li>
 </ul>
 <p>To get more familiar with the errors Python gives you, take a look at this <a href="https://betterstack.com/community/guides/scaling-python/python-errors/">summary of Python error messages</a>.</p>
+</div>
+<div id="exercises" class="section level2 hasAnchor" number="1.9">
+<h2><span class="header-section-number">1.9</span> Exercises<a href="intro-to-computing.html#exercises" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 1 can be found <a href="https://colab.research.google.com/drive/1AqVvktGz3LStUyu6dLJFsU2KoqNxgagT?usp=sharing">here</a>.</p>
 
 </div>
 </div>
@@ -421,7 +515,7 @@ <h2><span class="header-section-number">1.8</span> Tips on writing your first co
         </div>
       </div>
 <a href="index.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
-<a href="about-the-authors.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+<a href="working-with-data-structures.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
     </div>
   </div>
 <script src="libs/gitbook-2.6.7/js/app.min.js"></script>
diff --git a/docs/no_toc/reference-keys.txt b/docs/no_toc/reference-keys.txt
index d172de4..2bb8bd5 100644
--- a/docs/no_toc/reference-keys.txt
+++ b/docs/no_toc/reference-keys.txt
@@ -8,10 +8,44 @@ what-is-a-computer-program
 a-programming-language-has-following-elements
 google-colab-setup
 grammar-structure-1-evaluation-of-expressions
+function-machine-schema
 data-types
 grammar-structure-2-storing-data-types-in-the-variable-environment
 execution-rule-for-variable-assignment
 grammar-structure-3-evaluation-of-functions
 execution-rule-for-functions
 tips-on-writing-your-first-code
+exercises
+working-with-data-structures
+lists
+subsetting-lists
+subsetting-multiple-elements-of-lists
+objects-in-python
+methods-vs-functions
+dataframes
+what-does-a-dataframe-contain
+what-can-a-dataframe-do
+subsetting-dataframes
+exercises-1
+data-wrangling-part-1
+tidy-data
+our-working-tidy-data-depmap-project
+transform-what-do-you-want-to-do-with-this-dataframe
+lets-convert-our-implicit-subsetting-criteria-into-code
+summary-statistics
+simple-data-visualization
+chained-function-calls
+exercises-2
+data-wrangling-part-2
+creating-new-columns
+merging-two-dataframes-together
+grouping-and-summarizing-dataframes
+optional-multiple-grouping-multiple-columns-multiple-summary-statistics
+exercises-3
+data-visualization
+distributions-one-variable
+relational-between-2-continuous-variables
+categorical-between-1-categorical-and-1-continuous-variable
+basic-plot-customization
+exercises-4
 references
diff --git a/docs/no_toc/references.html b/docs/no_toc/references.html
index d03090c..7c34cff 100644
--- a/docs/no_toc/references.html
+++ b/docs/no_toc/references.html
@@ -4,18 +4,18 @@
 
   <meta charset="utf-8" />
   <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-  <title>Chapter 2 References | Introduction to Python</title>
+  <title>Chapter 6 References | Introduction to Python</title>
   <meta name="description" content="Description about Course/Book." />
   <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
 
-  <meta property="og:title" content="Chapter 2 References | Introduction to Python" />
+  <meta property="og:title" content="Chapter 6 References | Introduction to Python" />
   <meta property="og:type" content="book" />
   
   <meta property="og:description" content="Description about Course/Book." />
   
 
   <meta name="twitter:card" content="summary" />
-  <meta name="twitter:title" content="Chapter 2 References | Introduction to Python" />
+  <meta name="twitter:title" content="Chapter 6 References | Introduction to Python" />
   
   <meta name="twitter:description" content="Description about Course/Book." />
   
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -200,8 +244,8 @@ <h1>
 <div class="hero-image-container"> 
   <img class= "hero-image" src="assets/dasl_thin_main_image.png">
 </div>
-<div id="references" class="section level1 hasAnchor" number="2">
-<h1><span class="header-section-number">Chapter 2</span> References<a href="references.html#references" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<div id="references" class="section level1 hasAnchor" number="6">
+<h1><span class="header-section-number">Chapter 6</span> References<a href="references.html#references" class="anchor-section" aria-label="Anchor link to header"></a></h1>
 
 </div>
 <hr>
diff --git a/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png
new file mode 100644
index 0000000..30316b9
Binary files /dev/null and b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png differ
diff --git a/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png
new file mode 100644
index 0000000..791e0d8
Binary files /dev/null and b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png differ
diff --git a/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png
new file mode 100644
index 0000000..9ef4a07
Binary files /dev/null and b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png differ
diff --git a/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png
new file mode 100644
index 0000000..9ef4a07
Binary files /dev/null and b/docs/no_toc/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png
new file mode 100644
index 0000000..8d60f0b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-27.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-27.png
new file mode 100644
index 0000000..d954333
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-27.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-28.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-28.png
new file mode 100644
index 0000000..8d60f0b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-28.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-29.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-29.png
new file mode 100644
index 0000000..d954333
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-29.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-30.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-30.png
new file mode 100644
index 0000000..8d60f0b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-30.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-43.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-43.png
new file mode 100644
index 0000000..d954333
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-43.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-44.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-44.png
new file mode 100644
index 0000000..8d60f0b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-44.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-45.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-45.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-45.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png
new file mode 100644
index 0000000..bcb02b5
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-31.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-31.png
new file mode 100644
index 0000000..651791f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-31.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-32.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-32.png
new file mode 100644
index 0000000..bcb02b5
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-32.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-33.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-33.png
new file mode 100644
index 0000000..651791f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-33.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-34.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-34.png
new file mode 100644
index 0000000..bcb02b5
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-34.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-49.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-49.png
new file mode 100644
index 0000000..651791f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-49.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-50.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-50.png
new file mode 100644
index 0000000..bcb02b5
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-50.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-51.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-51.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-51.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png
new file mode 100644
index 0000000..c28c19e
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-35.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-35.png
new file mode 100644
index 0000000..b7724b4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-35.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-36.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-36.png
new file mode 100644
index 0000000..c28c19e
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-36.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-37.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-37.png
new file mode 100644
index 0000000..b7724b4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-37.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-38.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-38.png
new file mode 100644
index 0000000..c28c19e
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-38.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-55.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-55.png
new file mode 100644
index 0000000..b7724b4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-55.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-56.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-56.png
new file mode 100644
index 0000000..c28c19e
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-56.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-57.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-57.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-57.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png
new file mode 100644
index 0000000..955505c
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-39.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-39.png
new file mode 100644
index 0000000..c0237aa
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-39.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-40.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-40.png
new file mode 100644
index 0000000..955505c
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-40.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-41.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-41.png
new file mode 100644
index 0000000..c0237aa
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-41.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-42.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-42.png
new file mode 100644
index 0000000..955505c
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-42.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-61.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-61.png
new file mode 100644
index 0000000..c0237aa
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-61.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-62.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-62.png
new file mode 100644
index 0000000..955505c
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-62.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-63.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-63.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-63.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png
new file mode 100644
index 0000000..b48141d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png
new file mode 100644
index 0000000..7448370
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-43.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-43.png
new file mode 100644
index 0000000..b48141d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-43.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-44.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-44.png
new file mode 100644
index 0000000..7448370
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-44.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-45.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-45.png
new file mode 100644
index 0000000..b48141d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-45.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-46.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-46.png
new file mode 100644
index 0000000..7448370
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-46.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-47.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-47.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-47.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-67.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-67.png
new file mode 100644
index 0000000..b48141d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-67.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-68.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-68.png
new file mode 100644
index 0000000..7448370
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-68.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-69.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-69.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-69.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png
new file mode 100644
index 0000000..b3ce476
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-47.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-47.png
new file mode 100644
index 0000000..db3a0d4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-47.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-48.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-48.png
new file mode 100644
index 0000000..b3ce476
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-48.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-49.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-49.png
new file mode 100644
index 0000000..db3a0d4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-49.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-50.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-50.png
new file mode 100644
index 0000000..b3ce476
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-50.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-51.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-51.png
new file mode 100644
index 0000000..db3a0d4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-51.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-52.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-52.png
new file mode 100644
index 0000000..b3ce476
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-52.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-53.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-53.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-53.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-73.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-73.png
new file mode 100644
index 0000000..db3a0d4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-73.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-74.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-74.png
new file mode 100644
index 0000000..b3ce476
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-74.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-75.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-75.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-75.png differ
diff --git a/docs/resources/images/02-chapter_of_course_files/figure-html/unnamed-chunk-4-1.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-16-51.png
similarity index 100%
rename from docs/resources/images/02-chapter_of_course_files/figure-html/unnamed-chunk-4-1.png
rename to docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-16-51.png
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-16-53.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-16-53.png
new file mode 100644
index 0000000..b17edc4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-16-53.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-17-1.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-17-1.png
new file mode 100644
index 0000000..b17edc4
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-17-1.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-18-1.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-18-1.png
new file mode 100644
index 0000000..41f9ad6
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-18-1.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-19-3.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-19-3.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-19-3.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png
new file mode 100644
index 0000000..03f4cec
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-2.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-2.png
new file mode 100644
index 0000000..03f4cec
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-2.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-3.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-3.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-3.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png
new file mode 100644
index 0000000..c637f45
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-4.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-4.png
new file mode 100644
index 0000000..c637f45
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-4.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-5.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-5.png
new file mode 100644
index 0000000..774352f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-5.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-6.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-6.png
new file mode 100644
index 0000000..c637f45
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-6.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-7.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-7.png
new file mode 100644
index 0000000..774352f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-7.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-8.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-8.png
new file mode 100644
index 0000000..c637f45
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-8.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-9.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-9.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-9.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-10.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-10.png
new file mode 100644
index 0000000..2fc750a
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-10.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-13.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-13.png
new file mode 100644
index 0000000..c564928
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-13.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-14.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-14.png
new file mode 100644
index 0000000..2fc750a
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-14.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-15.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-15.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-15.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png
new file mode 100644
index 0000000..2fc750a
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-7.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-7.png
new file mode 100644
index 0000000..c564928
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-7.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-8.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-8.png
new file mode 100644
index 0000000..2fc750a
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-8.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-9.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-9.png
new file mode 100644
index 0000000..c564928
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-9.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-11.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-11.png
new file mode 100644
index 0000000..fdf11af
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-11.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-12.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-12.png
new file mode 100644
index 0000000..cdffe6b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-12.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-13.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-13.png
new file mode 100644
index 0000000..fdf11af
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-13.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-14.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-14.png
new file mode 100644
index 0000000..cdffe6b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-14.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-19.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-19.png
new file mode 100644
index 0000000..fdf11af
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-19.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-20.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-20.png
new file mode 100644
index 0000000..cdffe6b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-20.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-21.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-21.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-21.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png
new file mode 100644
index 0000000..cdffe6b
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-15.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-15.png
new file mode 100644
index 0000000..b9aafee
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-15.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-16.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-16.png
new file mode 100644
index 0000000..f59f40d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-16.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-17.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-17.png
new file mode 100644
index 0000000..b9aafee
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-17.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-18.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-18.png
new file mode 100644
index 0000000..f59f40d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-18.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-25.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-25.png
new file mode 100644
index 0000000..b9aafee
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-25.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-26.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-26.png
new file mode 100644
index 0000000..f59f40d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-26.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-27.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-27.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-27.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png
new file mode 100644
index 0000000..f59f40d
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png
new file mode 100644
index 0000000..c9ffa6f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-19.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-19.png
new file mode 100644
index 0000000..8ace120
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-19.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-20.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-20.png
new file mode 100644
index 0000000..c9ffa6f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-20.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-21.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-21.png
new file mode 100644
index 0000000..8ace120
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-21.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-22.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-22.png
new file mode 100644
index 0000000..c9ffa6f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-22.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-31.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-31.png
new file mode 100644
index 0000000..8ace120
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-31.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-32.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-32.png
new file mode 100644
index 0000000..c9ffa6f
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-32.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-33.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-33.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-33.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png
new file mode 100644
index 0000000..b82f5a0
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-23.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-23.png
new file mode 100644
index 0000000..0970063
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-23.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-24.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-24.png
new file mode 100644
index 0000000..b82f5a0
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-24.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-25.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-25.png
new file mode 100644
index 0000000..0970063
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-25.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-26.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-26.png
new file mode 100644
index 0000000..b82f5a0
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-26.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-37.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-37.png
new file mode 100644
index 0000000..0970063
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-37.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-38.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-38.png
new file mode 100644
index 0000000..b82f5a0
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-38.png differ
diff --git a/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-39.png b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-39.png
new file mode 100644
index 0000000..22f8179
Binary files /dev/null and b/docs/no_toc/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-39.png differ
diff --git a/docs/no_toc/search_index.json b/docs/no_toc/search_index.json
index aa8aa01..1264e16 100644
--- a/docs/no_toc/search_index.json
+++ b/docs/no_toc/search_index.json
@@ -1 +1 @@
-[["index.html", "Introduction to Python About this Course 0.1 Curriculum 0.2 Target Audience 0.3 Learning Objectives 0.4 Offerings", " Introduction to Python August, 2024 About this Course 0.1 Curriculum The course covers fundamentals of Python, a high-level programming language, and use it to wrangle data for analysis and visualization. 0.2 Target Audience The course is intended for researchers who want to learn coding for the first time with a data science application via the Python language. This course is also appropriate for folks who have explored data science or programming on their own and want to focus on some fundamentals. 0.3 Learning Objectives Analyze Tidy datasets in the Python programming language via data subsetting, joining, and transformations. Evaluate summary statistics and data visualization to understand scientific questions. Describe how the Python programming environment interpret complex expressions made out of functions, operations, and data structures, in a step-by-step way. Apply problem solving strategies to debug broken code. 0.4 Offerings This course is taught on a regular basis at Fred Hutch Cancer Center through the Data Science Lab. Announcements of course offering can be found here. "],["intro-to-computing.html", "Chapter 1 Intro to Computing 1.1 Goals of the course 1.2 What is a computer program? 1.3 A programming language has following elements: 1.4 Google Colab Setup 1.5 Grammar Structure 1: Evaluation of Expressions 1.6 Grammar Structure 2: Storing data types in the Variable Environment 1.7 Grammar Structure 3: Evaluation of Functions 1.8 Tips on writing your first code", " Chapter 1 Intro to Computing Welcome to Introduction to Python! Each week, we cover a chapter, which consists of a lesson and exercise. In our first week together, we will look at big conceptual themes in programming, see how code is run, and learn some basic grammar structures of programming. 1.1 Goals of the course In the next 6 weeks, we will explore: Fundamental concepts in high-level programming languages (Python, R, Julia, etc.) that is transferable: How do programs run, and how do we solve problems using functions and data structures? Beginning of data science fundamentals: How do you translate your scientific question to a data wrangling problem and answer it? Data science workflow. Image source: R for Data Science. Find a nice balance between the two throughout the course: we will try to reproduce a figure from a scientific publication using new data. 1.2 What is a computer program? A sequence of instructions to manipulate data for the computer to execute. A series of translations: English &lt;-&gt; Programming Code for Interpreter &lt;-&gt; Machine Code for Central Processing Unit (CPU) We will focus on English &lt;-&gt; Programming Code for Python Interpreter in this class. More importantly: How we organize ideas &lt;-&gt; Instructing a computer to do something. 1.3 A programming language has following elements: Grammar structure to construct expressions; combining expressions to create more complex expressions Encapsulate complex expressions via functions to create modular and reusable tasks Encapsulate complex data via data structures to allow efficient manipulation of data 1.4 Google Colab Setup Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user. Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, open up… Today, we will pay close attention to: Python Console (Execution): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you. Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text and Python code, and it helps us understand better the code we are writing. Variable Environment: Open it by clicking on the “{x}” button on the left-hand panel. Often, your code will store information in the Variable Environment, so that information can be reused. For instance, we often load in data and store it in the Variable Environment, and use it throughout rest of your Python code. The first thing we will do is see the different ways we can run Python code. You can do the following: Type something into the Python Console (Execution) and type enter, such as 2+2. The Python Console will run it and give you an output. Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data. Run every single Python code chunk via Runtime -&gt; Run all. Remember that the order that you run your code matters in programming. Your final product would be the result of Option 3, in which you run every Python code chunk from start to finish. However, sometimes it is nice to try out smaller parts of your code via Options 1 or 2. But you will be at risk of running your code out of order! To create your own content in the notebook, click on a section you want to insert content, and then click on “+ Code” or “+ Text” to add Python code or text, respectively. Python Notebook is great for data science work, because: It encourages reproducible data analysis, when you run your analysis from start to finish. It encourages excellent documentation, as you can have code, output from code, and prose combined together. It is flexible to use other programming languages, such as R. Now, we will get to the basics of programming grammar. 1.5 Grammar Structure 1: Evaluation of Expressions Expressions are be built out of operations or functions. Functions and operations take in data types, do something with them, and return another data type. We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it. For instance, consider the following expressions entered to the Python Console: 18 + 21 ## 39 max(18, 21) ## 21 max(18 + 21, 65) ## 65 18 + (21 + 65) ## 104 len(&quot;ATCG&quot;) ## 4 Here, our input data types to the operation are integer in lines 1-4 and our input data type to the function is string in line 5. We will go over common data types shortly. Operations are just functions in hiding. We could have written: from operator import add add(18, 21) ## 39 add(18, add(21, 65)) ## 104 Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to readable code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Because the add() function isn’t typically used, it is not automatically available, so we used the import statement to load it in.) 1.5.1 Data types Here are some common data types we will be using in this course. Data type name Data type shorthand Examples Integer int 2, 4 Float float 3.5, -34.1009 String str “hello”, “234-234-8594” Boolean bool True, False A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class: Function machine from algebra class. Here are some aspects of this schema to pay attention to: A programmer should not need to know how the function is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language. A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the len() function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs. 1.6 Grammar Structure 2: Storing data types in the Variable Environment To build up a computer program, we need to store our returned data type from our expression somewhere for downstream use. We can assign a variable to it as follows: x = 18 + 21 If you enter this in the Console, you will see that in the Variable Environment, the variable x has a value of 39. 1.6.1 Execution rule for variable assignment Evaluate the expression to the right of =. Bind variable to the left of = to the resulting value. The variable is stored in the Variable Environment. The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined. The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. When we work with large datasets, if you assign a variable to a data type larger than the available RAM, it will not work. More on this later. Look, now x can be reused downstream: x - 2 ## 37 y = x * 2 It is quite common for programmers to not know what data type a variable is while they are coding. To learn about the data type of a variable, use the type() function on any variable in Python: type(y) ## &lt;class &#39;int&#39;&gt; We should give useful variable names so that we know what to expect! Consider num_sales instead of y. 1.7 Grammar Structure 3: Evaluation of Functions Let’s look at functions a little bit more formally: A function has a function name, arguments, and returns a data type. 1.7.1 Execution rule for functions: Evaluate the function by its arguments, and if the arguments are functions or contains operations, evaluate those functions or operations first. The output of functions is called the returned value. Often, we will use multiple functions, in a nested way, or use parenthesis to change the order of operation. Being able to read nested operations, nested functions, and parenthesis is very important. Think about what the Python is going to do step-by–step in the line of code below: (len(&quot;hello&quot;) + 4) * 2 ## 18 If we don’t know how to use a function, such as pow() we can ask for help: ?pow pow(base, exp, mod=None) Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments Some types, such as ints, are able to use a more efficient algorithm when invoked using the three argument form. This shows the function takes in three input arguments: base, exp, and mod=None. When an argument has an assigned value of mod=None, that means the input argument already has a value, and you don’t need to specify anything, unless you want to. The following ways are equivalent ways of using the pow() function: pow(2, 3) ## 8 pow(base=2, exp=3) ## 8 pow(exp=3, base=2) ## 8 but this will give you something different: pow(3, 2) ## 9 And there is an operational equivalent: 2 ** 3 ## 8 1.8 Tips on writing your first code Computer = powerful + stupid Even the smallest spelling and formatting changes will cause unexpected output and errors! Write incrementally, test often Check your assumptions, especially using new functions, operations, and new data types. Live environments are great for testing, but not great for reproducibility. Ask for help! To get more familiar with the errors Python gives you, take a look at this summary of Python error messages. "],["about-the-authors.html", "About the Authors", " About the Authors These credits are based on our course contributors table guidelines.     Credits Names Pedagogy Lead Content Instructor(s) FirstName LastName Lecturer(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved Delivered the course in some way - video or audio Content Author(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved If any other authors besides lead instructor Content Contributor(s) (include section name/link in parentheses) - make new line if more than one section involved Wrote less than a chapter Content Editor(s)/Reviewer(s) Checked your content Content Director(s) Helped guide the content direction Content Consultants (include chapter name/link in parentheses or word “General”) - make new line if more than one chapter involved Gave high level advice on content Acknowledgments Gave small assistance to content but not to the level of consulting Production Content Publisher(s) Helped with publishing platform Content Publishing Reviewer(s) Reviewed overall content and aesthetics on publishing platform Technical Course Publishing Engineer(s) Helped with the code for the technical aspects related to the specific course generation Template Publishing Engineers Candace Savonen, Carrie Wright, Ava Hoffman Publishing Maintenance Engineer Candace Savonen Technical Publishing Stylists Carrie Wright, Ava Hoffman, Candace Savonen Package Developers (ottrpal) Candace Savonen, John Muschelli, Carrie Wright Art and Design Illustrator(s) Created graphics for the course Figure Artist(s) Created figures/plots for course Videographer(s) Filmed videos Videography Editor(s) Edited film Audiographer(s) Recorded audio Audiography Editor(s) Edited audio recordings Funding Funder(s) Institution/individual who funded course including grant number Funding Staff Staff members who help with funding   ## ─ Session info ─────────────────────────────────────────────────────────────── ## setting value ## version R version 4.3.2 (2023-10-31) ## os Ubuntu 22.04.4 LTS ## system x86_64, linux-gnu ## ui X11 ## language (EN) ## collate en_US.UTF-8 ## ctype en_US.UTF-8 ## tz Etc/UTC ## date 2024-08-07 ## pandoc 3.1.1 @ /usr/local/bin/ (via rmarkdown) ## ## ─ Packages ─────────────────────────────────────────────────────────────────── ## package * version date (UTC) lib source ## askpass 1.2.0 2023-09-03 [1] RSPM (R 4.3.0) ## bookdown 0.39.1 2024-06-11 [1] Github (rstudio/bookdown@f244cf1) ## bslib 0.6.1 2023-11-28 [1] RSPM (R 4.3.0) ## cachem 1.0.8 2023-05-01 [1] RSPM (R 4.3.0) ## cli 3.6.2 2023-12-11 [1] RSPM (R 4.3.0) ## devtools 2.4.5 2022-10-11 [1] RSPM (R 4.3.0) ## digest 0.6.34 2024-01-11 [1] RSPM (R 4.3.0) ## ellipsis 0.3.2 2021-04-29 [1] RSPM (R 4.3.0) ## evaluate 0.23 2023-11-01 [1] RSPM (R 4.3.0) ## fansi 1.0.6 2023-12-08 [1] RSPM (R 4.3.0) ## fastmap 1.1.1 2023-02-24 [1] RSPM (R 4.3.0) ## fs 1.6.3 2023-07-20 [1] RSPM (R 4.3.0) ## glue 1.7.0 2024-01-09 [1] RSPM (R 4.3.0) ## hms 1.1.3 2023-03-21 [1] RSPM (R 4.3.0) ## htmltools 0.5.7 2023-11-03 [1] RSPM (R 4.3.0) ## htmlwidgets 1.6.4 2023-12-06 [1] RSPM (R 4.3.0) ## httpuv 1.6.14 2024-01-26 [1] RSPM (R 4.3.0) ## httr 1.4.7 2023-08-15 [1] RSPM (R 4.3.0) ## jquerylib 0.1.4 2021-04-26 [1] RSPM (R 4.3.0) ## jsonlite 1.8.8 2023-12-04 [1] RSPM (R 4.3.0) ## knitr 1.47.3 2024-06-11 [1] Github (yihui/knitr@e1edd34) ## later 1.3.2 2023-12-06 [1] RSPM (R 4.3.0) ## lifecycle 1.0.4 2023-11-07 [1] RSPM (R 4.3.0) ## magrittr 2.0.3 2022-03-30 [1] RSPM (R 4.3.0) ## memoise 2.0.1 2021-11-26 [1] RSPM (R 4.3.0) ## mime 0.12 2021-09-28 [1] RSPM (R 4.3.0) ## miniUI 0.1.1.1 2018-05-18 [1] RSPM (R 4.3.0) ## openssl 2.1.1 2023-09-25 [1] RSPM (R 4.3.0) ## ottrpal 1.2.1 2024-06-11 [1] Github (jhudsl/ottrpal@828539f) ## pillar 1.9.0 2023-03-22 [1] RSPM (R 4.3.0) ## pkgbuild 1.4.3 2023-12-10 [1] RSPM (R 4.3.0) ## pkgconfig 2.0.3 2019-09-22 [1] RSPM (R 4.3.0) ## pkgload 1.3.4 2024-01-16 [1] RSPM (R 4.3.0) ## profvis 0.3.8 2023-05-02 [1] RSPM (R 4.3.0) ## promises 1.2.1 2023-08-10 [1] RSPM (R 4.3.0) ## purrr 1.0.2 2023-08-10 [1] RSPM (R 4.3.0) ## R6 2.5.1 2021-08-19 [1] RSPM (R 4.3.0) ## Rcpp 1.0.12 2024-01-09 [1] RSPM (R 4.3.0) ## readr 2.1.5 2024-01-10 [1] RSPM (R 4.3.0) ## remotes 2.4.2.1 2023-07-18 [1] RSPM (R 4.3.0) ## rlang 1.1.4 2024-06-04 [1] CRAN (R 4.3.2) ## rmarkdown 2.27.1 2024-06-11 [1] Github (rstudio/rmarkdown@e1c93a9) ## sass 0.4.8 2023-12-06 [1] RSPM (R 4.3.0) ## sessioninfo 1.2.2 2021-12-06 [1] RSPM (R 4.3.0) ## shiny 1.8.0 2023-11-17 [1] RSPM (R 4.3.0) ## stringi 1.8.3 2023-12-11 [1] RSPM (R 4.3.0) ## stringr 1.5.1 2023-11-14 [1] RSPM (R 4.3.0) ## tibble 3.2.1 2023-03-20 [1] CRAN (R 4.3.2) ## tzdb 0.4.0 2023-05-12 [1] RSPM (R 4.3.0) ## urlchecker 1.0.1 2021-11-30 [1] RSPM (R 4.3.0) ## usethis 2.2.3 2024-02-19 [1] RSPM (R 4.3.0) ## utf8 1.2.4 2023-10-22 [1] RSPM (R 4.3.0) ## vctrs 0.6.5 2023-12-01 [1] RSPM (R 4.3.0) ## xfun 0.44.4 2024-06-11 [1] Github (yihui/xfun@9da62cc) ## xml2 1.3.6 2023-12-04 [1] RSPM (R 4.3.0) ## xtable 1.8-4 2019-04-21 [1] RSPM (R 4.3.0) ## yaml 2.3.8 2023-12-11 [1] RSPM (R 4.3.0) ## ## [1] /usr/local/lib/R/site-library ## [2] /usr/local/lib/R/library ## ## ────────────────────────────────────────────────────────────────────────────── "],["references.html", "Chapter 2 References", " Chapter 2 References "],["404.html", "Page not found", " Page not found The page you requested cannot be found (perhaps it was moved or renamed). You may want to try searching to find the page's new location, or use the table of contents to find the page you are looking for. "]]
+[["index.html", "Introduction to Python About this Course 0.1 Curriculum 0.2 Target Audience 0.3 Learning Objectives 0.4 Offerings", " Introduction to Python September, 2024 About this Course 0.1 Curriculum The course covers fundamentals of Python, a high-level programming language, and use it to wrangle data for analysis and visualization. 0.2 Target Audience The course is intended for researchers who want to learn coding for the first time with a data science application via the Python language. This course is also appropriate for folks who have explored data science or programming on their own and want to focus on some fundamentals. 0.3 Learning Objectives Analyze Tidy datasets in the Python programming language via data subsetting, joining, and transformations. Evaluate summary statistics and data visualization to understand scientific questions. Describe how the Python programming environment interpret complex expressions made out of functions, operations, and data structures, in a step-by-step way. Apply problem solving strategies to debug broken code. 0.4 Offerings This course is taught on a regular basis at Fred Hutch Cancer Center through the Data Science Lab. Announcements of course offering can be found here. "],["intro-to-computing.html", "Chapter 1 Intro to Computing 1.1 Goals of the course 1.2 What is a computer program? 1.3 A programming language has following elements: 1.4 Google Colab Setup 1.5 Grammar Structure 1: Evaluation of Expressions 1.6 Grammar Structure 2: Storing data types in the Variable Environment 1.7 Grammar Structure 3: Evaluation of Functions 1.8 Tips on writing your first code 1.9 Exercises", " Chapter 1 Intro to Computing Welcome to Introduction to Python! Each week, we cover a chapter, which consists of a lesson and exercise. In our first week together, we will look at big conceptual themes in programming, see how code is run, and learn some basic grammar structures of programming. 1.1 Goals of the course In the next 6 weeks, we will explore: Fundamental concepts in high-level programming languages (Python, R, Julia, etc.) that is transferable: How do programs run, and how do we solve problems using functions and data structures? Beginning of data science fundamentals: How do you translate your scientific question to a data wrangling problem and answer it? Data science workflow. Image source: R for Data Science. Find a nice balance between the two throughout the course: we will try to reproduce a figure from a scientific publication using new data. 1.2 What is a computer program? A sequence of instructions to manipulate data for the computer to execute. A series of translations: English &lt;-&gt; Programming Code for Interpreter &lt;-&gt; Machine Code for Central Processing Unit (CPU) We will focus on English &lt;-&gt; Programming Code for Python Interpreter in this class. More importantly: How we organize ideas &lt;-&gt; Instructing a computer to do something. 1.3 A programming language has following elements: Grammar structure to construct expressions; combining expressions to create more complex expressions Encapsulate complex expressions via functions to create modular and reusable tasks Encapsulate complex data via data structures to allow efficient manipulation of data 1.4 Google Colab Setup Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user. Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, you can view it here. Today, we will pay close attention to: Python Console (“Executions”): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you. Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text and Python code, and it helps us understand better the code we are writing. Variable Environment: Open it by clicking on the “{x}” button on the left-hand panel. Often, your code will store information in the Variable Environment, so that information can be reused. For instance, we often load in data and store it in the Variable Environment, and use it throughout rest of your Python code. The first thing we will do is see the different ways we can run Python code. You can do the following: Type something into the Python Console (Execution) and click the arrow button, such as 2+2. The Python Console will run it and give you an output. Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data. Run every single Python code chunk via Runtime -&gt; Run all. Remember that the order that you run your code matters in programming. Your final product would be the result of Option 3, in which you run every Python code chunk from start to finish. However, sometimes it is nice to try out smaller parts of your code via Options 1 or 2. But you will be at risk of running your code out of order! To create your own content in the notebook, click on a section you want to insert content, and then click on “+ Code” or “+ Text” to add Python code or text, respectively. Python Notebook is great for data science work, because: It encourages reproducible data analysis, when you run your analysis from start to finish. It encourages excellent documentation, as you can have code, output from code, and prose combined together. It is flexible to use other programming languages, such as R. The version of Python used in this course and in Google Colab is Python 3, which is the version of Python that is most supported. Some Python software is written in Python 2, which is very similar but has some notable differences. Now, we will get to the basics of programming grammar. 1.5 Grammar Structure 1: Evaluation of Expressions Expressions are be built out of operations or functions. Functions and operations take in data types as inputs, do something with them, and return another data type as ouput. We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it. For instance, consider the following expressions entered to the Python Console: 18 + 21 ## 39 max(18, 21) ## 21 max(18 + 21, 65) ## 65 18 + (21 + 65) ## 104 len(&quot;ATCG&quot;) ## 4 Here, our input data types to the operation are integer in lines 1-4 and our input data type to the function is string in line 5. We will go over common data types shortly. Operations are just functions in hiding. We could have written: from operator import add add(18, 21) ## 39 add(18, add(21, 65)) ## 104 Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to readable code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Most functions in Python are stored in a collection of functions called modules that needs to be loaded. The import statement gives us permission to access the functions in the module “operator”.) 1.5.1 Function machine schema A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class: Function machine from algebra class. Here are some aspects of this schema to pay attention to: A programmer should not need to know how the function or operation is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language. A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the len() function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs. 1.5.2 Data types Here are some common data types we will be using in this course. Data type name Data type shorthand Examples Integer int 2, 4 Float float 3.5, -34.1009 String str “hello”, “234-234-8594” Boolean bool True, False 1.6 Grammar Structure 2: Storing data types in the Variable Environment To build up a computer program, we need to store our returned data type from our expression somewhere for downstream use. We can assign a variable to it as follows: x = 18 + 21 If you enter this in the Console, you will see that in the Variable Environment, the variable x has a value of 39. 1.6.1 Execution rule for variable assignment Evaluate the expression to the right of =. Bind variable to the left of = to the resulting value. The variable is stored in the Variable Environment. The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined. The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. Look, now x can be reused downstream: x - 2 ## 37 y = x * 2 It is quite common for programmers to have to look up the data type of a variable while they are coding. To learn about the data type of a variable, use the type() function on any variable in Python: type(y) ## &lt;class &#39;int&#39;&gt; We should give useful variable names so that we know what to expect! If you are working with numerical sales data, consider num_sales instead of y. 1.7 Grammar Structure 3: Evaluation of Functions Let’s look at functions a little bit more formally: A function has a function name, arguments, and returns a data type. 1.7.1 Execution rule for functions: Evaluate the function by its arguments if there’s any, and if the arguments are functions or contains operations, evaluate those functions or operations first. The output of functions is called the returned value. Often, we will use multiple functions in a nested way, and it is important to understand how the Python console understand the order of operation. We can also use parenthesis to change the order of operation. Think about what the Python is going to do step-by–step in the lines of code below: max(len(&quot;hello&quot;), 4) ## 5 (len(&quot;pumpkin&quot;) - 8) * 2 ## -2 If we don’t know how to use a function, such as pow(), we can ask for help: ?pow pow(base, exp, mod=None) Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments Some types, such as ints, are able to use a more efficient algorithm when invoked using the three argument form. We can also find a similar help document, in a nicer rendered form online. We will practice looking at function documentation throughout the course, because that is a fundamental skill to learn more functions on your own. The documentation shows the function takes in three input arguments: base, exp, and mod=None. When an argument has an assigned value of mod=None, that means the input argument already has a value, and you don’t need to specify anything, unless you want to. The following ways are equivalent ways of using the pow() function: pow(2, 3) ## 8 pow(base=2, exp=3) ## 8 pow(exp=3, base=2) ## 8 but this will give you something different: pow(3, 2) ## 9 And there is an operational equivalent: 2 ** 3 ## 8 We will mostly look at functions with input arguments and return types in this course, but not all functions need to have input arguments and output return. Let’s look at some examples of functions that don’t always have an input or output: Function call What it takes in What it does Returns pow(a, b) integer a, integer b Raises a to the bth power. Integer time.sleep(x) Integer x Waits for x seconds. None dir() Nothing Gives a list of all the variables defined in the environment. List 1.8 Tips on writing your first code Computer = powerful + stupid Computers are excellent at doing something specific over and over again, but is extremely rigid and lack flexibility. Here are some tips that is helpful for beginners: Write incrementally, test often. Don’t be afraid to break things: it is how we learn how things work in programming. Check your assumptions, especially using new functions, operations, and new data types. Live environments are great for testing, but not great for reproducibility. Ask for help! To get more familiar with the errors Python gives you, take a look at this summary of Python error messages. 1.9 Exercises Exercise for week 1 can be found here. "],["working-with-data-structures.html", "Chapter 2 Working with data structures 2.1 Lists 2.2 Objects in Python 2.3 Methods vs Functions 2.4 Dataframes 2.5 What does a Dataframe contain? 2.6 What can a Dataframe do? 2.7 Subsetting Dataframes 2.8 Exercises", " Chapter 2 Working with data structures In our second lesson, we start to look at two data structures, Lists and Dataframes, that can handle a large amount of data for analysis. 2.1 Lists In the first exercise, you started to explore data structures, which store information about data types. You explored lists, which is an ordered collection of data types or data structures. Each element of a list contains a data type or another data structure. We can now store a vast amount of information in a list, and assign it to a single variable. Even more, we can use operations and functions on a list, modifying many elements within the list at once! This makes analyzing data much more scalable and less repetitive. We create a list via the bracket [ ] operation. staff = [&quot;chris&quot;, &quot;ted&quot;, &quot;jeff&quot;] chrNum = [2, 3, 1, 2, 2] mixedList = [False, False, False, &quot;A&quot;, &quot;B&quot;, 92] 2.1.1 Subsetting lists To access an element of a list, you can use the bracket notation [ ] to access the elements of the list. We simply access an element via the “index” number - the location of the data within the list. Here’s the tricky thing about the index number: it starts at 0! 1st element of chrNum: chrNum[0] 2nd element of chrNum: chrNum[1] … 5th element of chrNum: chrNum[4] With subsetting, you can modify elements of a list or use the element of a list as part of an expression. 2.1.2 Subsetting multiple elements of lists Suppose you want to access multiple elements of a list, such as accessing the first three elements of chrNum. You would use the slice operator :, which specifies: the index number to start the index number to stop, plus one. If you want to access the first three elements of chrNum: chrNum[0:3] ## [2, 3, 1] The first element’s index number is 0, the third element’s index number is 2, plus 1, which is 3. If you want to access the second and third elements of chrNum: chrNum[1:3] ## [3, 1] Another way of accessing the first 3 elements of chrNum: chrNum[:3] ## [2, 3, 1] Here, the start index number was not specified. When the start or stop index is not specified, it implies that you are subsetting starting the from the beginning of the list or subsetting to the end of the list, respectively. Here’s another example, using negative indicies to count from 3 elements from the end of the list: chrNum[-3:] ## [1, 2, 2] You can find more discussion of list slicing, using negative indicies and incremental slicing, here. 2.2 Objects in Python The list data structure has an organization and functionality that metaphorically represents a pen-and-paper list in our physical world. Like a physical object, we have examined: What does it contain (in terms of data)? What can it do (in terms of functions)? And if it “makes sense” to us, then it is well-designed. The list data structure we have been working with is an example of an Object. The definition of an object allows us to ask the questions above: what does it contain, and what can it do? It is an organizational tool for a collection of data and functions that we can relate to, like a physical object. Formally, an object contains the following: Value that holds the essential data for the object. Attributes that hold subset or additional data for the object. Functions called Methods that are for the object and have to take in the variable referenced as an input This organizing structure on an object applies to pretty much all Python data types and data structures. Let’s see how this applies to the list: Value: the contents of the list, such as [2, 3, 4]. Attributes that store additional values: Not relevant for lists. Methods that can be used on the object: chrNum.count(2) counts the number of instances 2 appears as an element of chrNum. Object methods are functions that does something with the object you are using it on. You should think about chrNum.count(2) as a function that takes in chrNum and 2 as inputs. If you want to use the count function on list mixedList, you would use mixedList.count(x). Here are some more examples of methods with lists: Function method What it takes in What it does Returns chrNum.count(x) list chrNum, data type x Counts the number of instances x appears as an element of chrNum. Integer chrNum.append(x) list chrNum, data type x Appends x to the end of the chrNum. None (but chrNum is modified!) chrNum.sort() list chrNum Sorts chrNum by ascending order. None (but chrNum is modified!) chrNum.reverse() list chrNum Reverses the order of chrNum. None (but chrNum is modified!) 2.3 Methods vs Functions Methods have to take in the object of interest as an input: chrNum.count(2) automatically treat chrNum as an input. Methods are built for a specific Object type. Functions do not have an implied input: len(chrNum) requires specifying a list in the input. Otherwise, there is no strong distinction between the two. 2.4 Dataframes A Dataframe is a two-dimensional data structure that stores data like a spreadsheet does. The Dataframe data structure is found within a Python module called “Pandas”. A Python module is an organized collection of functions and data structures. The import statement below gives us permission to access the “Pandas” module via the variable pd. To load in a Dataframe from existing spreadsheet data, we use the function pd.read_csv(): import pandas as pd metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) type(metadata) ## &lt;class &#39;pandas.core.frame.DataFrame&#39;&gt; There is a similar function pd.read_excel() for loading in Excel spreadsheets. Let’s investigate the Dataframe as an object: What does a Dataframe contain (values, attributes)? What can a Dataframe do (methods)? 2.5 What does a Dataframe contain? We first take a look at the contents: metadata ## ModelID ... OncotreeLineage ## 0 ACH-000001 ... Ovary/Fallopian Tube ## 1 ACH-000002 ... Myeloid ## 2 ACH-000003 ... Bowel ## 3 ACH-000004 ... Myeloid ## 4 ACH-000005 ... Myeloid ## ... ... ... ... ## 1859 ACH-002968 ... Esophagus/Stomach ## 1860 ACH-002972 ... Esophagus/Stomach ## 1861 ACH-002979 ... Esophagus/Stomach ## 1862 ACH-002981 ... Esophagus/Stomach ## 1863 ACH-003071 ... Lung ## ## [1864 rows x 30 columns] It looks like there are 1864 rows and 30 columns in this Dataframe, and when we display it it shows some of the data. metadata ## ModelID ... OncotreeLineage ## 0 ACH-000001 ... Ovary/Fallopian Tube ## 1 ACH-000002 ... Myeloid ## 2 ACH-000003 ... Bowel ## 3 ACH-000004 ... Myeloid ## 4 ACH-000005 ... Myeloid ## ... ... ... ... ## 1859 ACH-002968 ... Esophagus/Stomach ## 1860 ACH-002972 ... Esophagus/Stomach ## 1861 ACH-002979 ... Esophagus/Stomach ## 1862 ACH-002981 ... Esophagus/Stomach ## 1863 ACH-003071 ... Lung ## ## [1864 rows x 30 columns] We can look at specific columns by looking at attributes via the dot operation. We can also look at the columns via the bracket operation. metadata.ModelID ## 0 ACH-000001 ## 1 ACH-000002 ## 2 ACH-000003 ## 3 ACH-000004 ## 4 ACH-000005 ## ... ## 1859 ACH-002968 ## 1860 ACH-002972 ## 1861 ACH-002979 ## 1862 ACH-002981 ## 1863 ACH-003071 ## Name: ModelID, Length: 1864, dtype: object metadata[&#39;ModelID&#39;] ## 0 ACH-000001 ## 1 ACH-000002 ## 2 ACH-000003 ## 3 ACH-000004 ## 4 ACH-000005 ## ... ## 1859 ACH-002968 ## 1860 ACH-002972 ## 1861 ACH-002979 ## 1862 ACH-002981 ## 1863 ACH-003071 ## Name: ModelID, Length: 1864, dtype: object The names of all columns is stored as an attribute, which can be accessed via the dot operation. metadata.columns ## Index([&#39;ModelID&#39;, &#39;PatientID&#39;, &#39;CellLineName&#39;, &#39;StrippedCellLineName&#39;, &#39;Age&#39;, ## &#39;SourceType&#39;, &#39;SangerModelID&#39;, &#39;RRID&#39;, &#39;DepmapModelType&#39;, &#39;AgeCategory&#39;, ## &#39;GrowthPattern&#39;, &#39;LegacyMolecularSubtype&#39;, &#39;PrimaryOrMetastasis&#39;, ## &#39;SampleCollectionSite&#39;, &#39;Sex&#39;, &#39;SourceDetail&#39;, &#39;LegacySubSubtype&#39;, ## &#39;CatalogNumber&#39;, &#39;CCLEName&#39;, &#39;COSMICID&#39;, &#39;PublicComments&#39;, ## &#39;WTSIMasterCellID&#39;, &#39;EngineeredModel&#39;, &#39;TreatmentStatus&#39;, ## &#39;OnboardedMedia&#39;, &#39;PlateCoating&#39;, &#39;OncotreeCode&#39;, &#39;OncotreeSubtype&#39;, ## &#39;OncotreePrimaryDisease&#39;, &#39;OncotreeLineage&#39;], ## dtype=&#39;object&#39;) The number of rows and columns are also stored as an attribute: metadata.shape ## (1864, 30) 2.6 What can a Dataframe do? We can use the .head() and .tail() methods to look at the first few rows and last few rows of metadata, respectively: metadata.head() ## ModelID PatientID ... OncotreePrimaryDisease OncotreeLineage ## 0 ACH-000001 PT-gj46wT ... Ovarian Epithelial Tumor Ovary/Fallopian Tube ## 1 ACH-000002 PT-5qa3uk ... Acute Myeloid Leukemia Myeloid ## 2 ACH-000003 PT-puKIyc ... Colorectal Adenocarcinoma Bowel ## 3 ACH-000004 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## 4 ACH-000005 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## ## [5 rows x 30 columns] metadata.tail() ## ModelID PatientID ... OncotreePrimaryDisease OncotreeLineage ## 1859 ACH-002968 PT-pjhrsc ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1860 ACH-002972 PT-dkXZB1 ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1861 ACH-002979 PT-lyHTzo ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1862 ACH-002981 PT-Z9akXf ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1863 ACH-003071 PT-LAGmLq ... Lung Neuroendocrine Tumor Lung ## ## [5 rows x 30 columns] Both of these functions (without input arguments) are considered as methods: they are functions that does something with the Dataframe you are using it on. You should think about metadata.head() as a function that takes in metadata as an input. If we had another Dataframe called my_data and you want to use the same function, you will have to say my_data.head(). 2.7 Subsetting Dataframes Perhaps the most important operation you will can do with Dataframes is subsetting them. There are two ways to do it. The first way is to subset by numerical indicies, exactly like how we did for lists. You will use the iloc attribute and bracket operations, and you give two slices: one for the row, and one for the column. Let’s start with a small dataframe to see how it works before returning to metadata: df = pd.DataFrame(data={&#39;status&#39;: [&quot;treated&quot;, &quot;untreated&quot;, &quot;untreated&quot;, &quot;discharged&quot;, &quot;treated&quot;], &#39;age_case&#39;: [25, 43, 21, 65, 7], &#39;age_control&#39;: [49, 20, 32, 25, 32]}) df ## status age_case age_control ## 0 treated 25 49 ## 1 untreated 43 20 ## 2 untreated 21 32 ## 3 discharged 65 25 ## 4 treated 7 32 Here is how the dataframe looks like with the row and column index numbers: Subset the first fourth rows, and the first two columns: Now, back to metadata dataframe: Subset the first 5 rows, and first two columns: metadata.iloc[:5, :2] ## ModelID PatientID ## 0 ACH-000001 PT-gj46wT ## 1 ACH-000002 PT-5qa3uk ## 2 ACH-000003 PT-puKIyc ## 3 ACH-000004 PT-q4K2cp ## 4 ACH-000005 PT-q4K2cp If we want a custom slice that is not sequential, we can use an integer list. Subset the last 5 rows, and the 1st and 10 and 21th column: metadata.iloc[5:, [1, 10, 21]] ## PatientID GrowthPattern WTSIMasterCellID ## 5 PT-ej13Dz Suspension 2167.0 ## 6 PT-NOXwpH Adherent 569.0 ## 7 PT-fp8PeY Adherent 1806.0 ## 8 PT-puKIyc Adherent 2104.0 ## 9 PT-AR7W9o Adherent NaN ## ... ... ... ... ## 1859 PT-pjhrsc Organoid NaN ## 1860 PT-dkXZB1 Organoid NaN ## 1861 PT-lyHTzo Organoid NaN ## 1862 PT-Z9akXf Organoid NaN ## 1863 PT-LAGmLq Suspension NaN ## ## [1859 rows x 3 columns] When we subset via numerical indicies, it’s called explicit subsetting. This is a great way to start thinking about subsetting your dataframes for analysis, but explicit subsetting can lead to some inconsistencies in the long run. For instance, suppose your collaborator added a new cell line to the metadata and changed the order of the column. Then your code to subset the last 5 rows and the columns will get you a different answer once the spreadsheet is changed. The second way is to subset by the column name and comparison operators, also known as implicit subsetting. This is much more robust in data analysis practice. You will learn about it next week! 2.8 Exercises Exercise for week 2 can be found here. "],["data-wrangling-part-1.html", "Chapter 3 Data Wrangling, Part 1 3.1 Tidy Data 3.2 Our working Tidy Data: DepMap Project 3.3 Transform: “What do you want to do with this Dataframe”? 3.4 Summary Statistics 3.5 Simple data visualization 3.6 Exercises", " Chapter 3 Data Wrangling, Part 1 From our first two lessons, we are now equipped with enough fundamental programming skills to apply it to various steps in the data science workflow, which is a natural cycle that occurs in data analysis. Data science workflow. Image source: R for Data Science. For the rest of the course, we focus on Transform and Visualize with the assumption that our data is in a nice, “Tidy format”. First, we need to understand what it means for a data to be “Tidy”. 3.1 Tidy Data Here, we describe a standard of organizing data. It is important to have standards, as it facilitates a consistent way of thinking about data organization and building tools (functions) that make use of that standard. The principles of tidy data, developed by Hadley Wickham: Each variable must have its own column. Each observation must have its own row. Each value must have its own cell. If you want to be technical about what variables and observations are, Hadley Wickham describes: A variable contains all values that measure the same underlying attribute (like height, temperature, duration) across units. An observation contains all values measured on the same unit (like a person, or a day, or a race) across attributes. A tidy dataframe. Image source: R for Data Science. 3.2 Our working Tidy Data: DepMap Project The Dependency Map project is a multi-omics profiling of cancer cell lines combined with functional assays such as CRISPR and drug sensitivity to help identify cancer vulnerabilities and drug targets. Here are some of the data that we have public access to. We have been looking at the metadata since last session. Metadata Somatic mutations Gene expression Drug sensitivity CRISPR knockout and more… Let’s load these datasets in, and see how these datasets fit the definition of Tidy data: import pandas as pd metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) mutation = pd.read_csv(&quot;classroom_data/mutation.csv&quot;) expression = pd.read_csv(&quot;classroom_data/expression.csv&quot;) metadata.head() ## ModelID PatientID ... OncotreePrimaryDisease OncotreeLineage ## 0 ACH-000001 PT-gj46wT ... Ovarian Epithelial Tumor Ovary/Fallopian Tube ## 1 ACH-000002 PT-5qa3uk ... Acute Myeloid Leukemia Myeloid ## 2 ACH-000003 PT-puKIyc ... Colorectal Adenocarcinoma Bowel ## 3 ACH-000004 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## 4 ACH-000005 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## ## [5 rows x 30 columns] mutation.head() ## ModelID CACNA1D_Mut CYP2D6_Mut ... CCDC28A_Mut C1orf194_Mut U2AF1_Mut ## 0 ACH-000001 False False ... False False False ## 1 ACH-000002 False False ... False False False ## 2 ACH-000004 False False ... False False False ## 3 ACH-000005 False False ... False False False ## 4 ACH-000006 False False ... False False False ## ## [5 rows x 540 columns] expression.head() ## ModelID ENPP4_Exp CREBBP_Exp ... OR5D13_Exp C2orf81_Exp OR8S1_Exp ## 0 ACH-001113 2.280956 4.094236 ... 0.0 1.726831 0.0 ## 1 ACH-001289 3.622930 3.606442 ... 0.0 0.790772 0.0 ## 2 ACH-001339 0.790772 2.970854 ... 0.0 0.575312 0.0 ## 3 ACH-001538 3.485427 2.801159 ... 0.0 1.077243 0.0 ## 4 ACH-000242 0.879706 3.327687 ... 0.0 0.722466 0.0 ## ## [5 rows x 536 columns] Dataframe The observation is Some variables are Some values are metadata Cell line ModelID, Age, OncotreeLineage “ACH-000001”, 60, “Myeloid” expression Cell line KRAS_Exp 2.4, .3 mutation Cell line KRAS_Mut TRUE, FALSE 3.3 Transform: “What do you want to do with this Dataframe”? Remember that a major theme of the course is about: How we organize ideas &lt;-&gt; Instructing a computer to do something. Until now, we haven’t focused too much on how we organize our scientific ideas to interact with what we can do with code. Let’s pivot to write our code driven by our scientific curiosity. After we are sure that we are working with Tidy data, we can ponder how we want to transform our data that satisfies our scientific question. We will look at several ways we can transform Tidy data, starting with subsetting columns and rows. Here’s a starting prompt: In the metadata dataframe, which rows would you subset for and columns would you subset for that relate to a scientific question? We have been using explicit subsetting with numerical indicies, such as “I want to filter for rows 20-50 and select columns 2 and 8”. We are now going to switch to implicit subsetting in which we describe the subsetting criteria via comparision operators and column names, such as: “I want to subset for rows such that the OncotreeLineage is breast cancer and subset for columns Age and Sex.” Notice that when we subset for rows in an implicit way, we formulate our criteria in terms of the columns.This is because we are guaranteed to have column names in Dataframes, but not row names. 3.3.0.1 Let’s convert our implicit subsetting criteria into code! To subset for rows implicitly, we will use the conditional operators on Dataframe columns you used in Exercise 2. To formulate a conditional operator expression that OncotreeLineage is breast cancer: metadata[&#39;OncotreeLineage&#39;] == &quot;Lung&quot; ## 0 False ## 1 False ## 2 False ## 3 False ## 4 False ## ... ## 1859 False ## 1860 False ## 1861 False ## 1862 False ## 1863 True ## Name: OncotreeLineage, Length: 1864, dtype: bool Then, we will use the .loc operation (which is different than .iloc operation!) and subsetting brackets to subset rows and columns Age and Sex at the same time: metadata.loc[metadata[&#39;OncotreeLineage&#39;] == &quot;Lung&quot;, [&quot;Age&quot;, &quot;Sex&quot;]] ## Age Sex ## 10 39.0 Female ## 13 44.0 Male ## 19 55.0 Female ## 27 39.0 Female ## 28 45.0 Male ## ... ... ... ## 1745 52.0 Male ## 1819 84.0 Male ## 1820 57.0 Female ## 1822 53.0 Male ## 1863 62.0 Male ## ## [241 rows x 2 columns] What’s going on here? The first component of the subset, metadata['OncotreeLineage'] == \"Lung\", subsets for the rows. It gives us a column of True and False values, and we keep rows that correspond to True values. Then, we specify the column names we want to subset for via a list. Here’s another example: df = pd.DataFrame(data={&#39;status&#39;: [&quot;treated&quot;, &quot;untreated&quot;, &quot;untreated&quot;, &quot;discharged&quot;, &quot;treated&quot;], &#39;age_case&#39;: [25, 43, 21, 65, 7], &#39;age_control&#39;: [49, 20, 32, 25, 32]}) df ## status age_case age_control ## 0 treated 25 49 ## 1 untreated 43 20 ## 2 untreated 21 32 ## 3 discharged 65 25 ## 4 treated 7 32 “I want to subset for rows such that the status is”treated” and subset for columns status and age_case.” df.loc[df.status == &quot;treated&quot;, [&quot;status&quot;, &quot;age_case&quot;]] ## status age_case ## 0 treated 25 ## 4 treated 7 3.4 Summary Statistics Now that your Dataframe has be transformed based on your scientific question, you can start doing some analysis on it! A common data science task is to examine summary statistics of a dataset, which summarizes the all the values from a variable in a numeric summary, such as mean, median, or mode. If we look at the data structure of a Dataframe’s column, it is actually not a List, but an object called Series. It has methods can compute summary statistics for us. Let’s take a look at a few popular examples: Function method What it takes in What it does Returns metadata.Age.mean() metadata.Age as a numeric Series Computes the mean value of the Age column. Float (NumPy) metadata['Age'].median() metadata['Age'] as a numeric Series Computes the median value of the Age column. Float (NumPy) metadata.Age.max() metadata.Age as a numeric Series Computes the max value of the Age column. Float (NumPy) metadata.OncotreeSubtype.value_counts() metadata.OncotreeSubtype as a string Series Creates a frequency table of all unique elements in OncotreeSubtype column. Series Let’s try it out, with some nice print formatting: print(&quot;Mean value of Age column:&quot;, metadata[&#39;Age&#39;].mean()) ## Mean value of Age column: 47.45187165775401 print(&quot;Frequency of column&quot;, metadata.OncotreeLineage.value_counts()) ## Frequency of column OncotreeLineage ## Lung 241 ## Lymphoid 209 ## CNS/Brain 123 ## Skin 118 ## Esophagus/Stomach 95 ## Breast 92 ## Bowel 87 ## Head and Neck 81 ## Myeloid 77 ## Bone 75 ## Ovary/Fallopian Tube 74 ## Pancreas 65 ## Kidney 64 ## Peripheral Nervous System 55 ## Soft Tissue 54 ## Uterus 41 ## Fibroblast 41 ## Biliary Tract 40 ## Bladder/Urinary Tract 39 ## Normal 39 ## Pleura 35 ## Liver 28 ## Cervix 25 ## Eye 19 ## Thyroid 18 ## Prostate 14 ## Vulva/Vagina 5 ## Ampulla of Vater 4 ## Testis 4 ## Adrenal Gland 1 ## Other 1 ## Name: count, dtype: int64 Notice that the output of some of these methods are Float (NumPy). This refers to a Python Object called NumPy that is extremely popular for scientific computing, but we’re not focused on that in this course.) 3.5 Simple data visualization We will dedicate extensive time later this course to talk about data visualization, but the Dataframe’s column, Series, has a method called .plot() that can help us make simple plots for one variable. The .plot() method will by default make a line plot, but it is not necessary the plot style we want, so we can give the optional argument kind a String value to specify the plot style. We use it for making a histogram or bar plot. Plot style Useful for kind = Code Histogram Numerics “hist” metadata.Age.plot(kind = \"hist\") Bar plot Strings “bar” metadata.OncotreeSubtype.value_counts().plot(kind = \"bar\") Let’s look at a histogram: import matplotlib.pyplot as plt plt.figure() metadata.Age.plot(kind = &quot;hist&quot;) plt.show() Let’s look at a bar plot: plt.figure() metadata.OncotreeLineage.value_counts().plot(kind = &quot;bar&quot;) plt.show() (The plt.figure() and plt.show() functions are used to render the plots on the website, but you don’t need to use it for your exercises. We will discuss this in more detail during our week of data visualization.) 3.5.0.1 Chained function calls Let’s look at our bar plot syntax more carefully. We start with the column metadata.OncotreeLineage, and then we first use the method .value_counts() to get a Series of a frequency table. Then, we take the frequency table Series and use the .plot() method. It is quite common in Python to have multiple “chained” function calls, in which the output of .value_counts() is used for the input of .plot() all in one line of code. It takes a bit of time to get used to this! Here’s another example of a chained function call, which looks quite complex, but let’s break it down: plt.figure() metadata.loc[metadata.AgeCategory == &quot;Adult&quot;, ].OncotreeLineage.value_counts().plot(kind=&quot;bar&quot;) plt.show() We first take the entire metadata and do some subsetting, which outputs a Dataframe. We access the OncotreeLineage column, which outputs a Series. We use the method .value_counts(), which outputs a Series. We make a plot out of it! We could have, alternatively, done this in several lines of code: plt.figure() metadata_subset = metadata.loc[metadata.AgeCategory == &quot;Adult&quot;, ] metadata_subset_lineage = metadata_subset.OncotreeLineage lineage_freq = metadata_subset_lineage.value_counts() lineage_freq.plot(kind = &quot;bar&quot;) plt.show() These are two different styles of code, but they do the exact same thing. It’s up to you to decide what is easier for you to understand. 3.6 Exercises Exercise for week 3 can be found here. "],["data-wrangling-part-2.html", "Chapter 4 Data Wrangling, Part 2 4.1 Creating new columns 4.2 Merging two Dataframes together 4.3 Grouping and summarizing Dataframes 4.4 Exercises", " Chapter 4 Data Wrangling, Part 2 We will continue to learn about data analysis with Dataframes. Let’s load our three Dataframes from the Depmap project in again: import pandas as pd import numpy as np metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) mutation = pd.read_csv(&quot;classroom_data/mutation.csv&quot;) expression = pd.read_csv(&quot;classroom_data/expression.csv&quot;) 4.1 Creating new columns Often, we want to perform some kind of transformation on our data’s columns: perhaps you want to add the values of columns together, or perhaps you want to represent your column in a different scale. To create a new column, you simply modify it as if it exists using the bracket operation [ ], and the column will be created: metadata[&#39;AgePlusTen&#39;] = metadata[&#39;Age&#39;] + 10 expression[&#39;KRAS_NRAS_exp&#39;] = expression[&#39;KRAS_Exp&#39;] + expression[&#39;NRAS_Exp&#39;] expression[&#39;log_PIK3CA_Exp&#39;] = np.log(expression[&#39;PIK3CA_Exp&#39;]) where np.log(x) is a function imported from the module NumPy that takes in a numeric and returns the log-transformed value. Note: you cannot create a new column referring to the attribute of the Dataframe, such as: expression.KRAS_Exp_log = np.log(expression.KRAS_Exp). 4.2 Merging two Dataframes together Suppose we have the following Dataframes: expression ModelID PIK3CA_Exp log_PIK3CA_Exp “ACH-001113” 5.138733 1.636806 “ACH-001289” 3.184280 1.158226 “ACH-001339” 3.165108 1.152187 metadata ModelID OncotreeLineage Age “ACH-001113” “Lung” 69 “ACH-001289” “CNS/Brain” NaN “ACH-001339” “Skin” 14 Suppose that I want to compare the relationship between OncotreeLineage and PIK3CA_Exp, but they are columns in different Dataframes. We want a new Dataframe that looks like this: ModelID PIK3CA_Exp log_PIK3CA_Exp OncotreeLineage Age “ACH-001113” 5.138733 1.636806 “Lung” 69 “ACH-001289” 3.184280 1.158226 “CNS/Brain” NaN “ACH-001339” 3.165108 1.152187 “Skin” 14 We see that in both dataframes, the rows (observations) represent cell lines. there is a common column ModelID, with shared values between the two dataframes that can faciltate the merging process. We call this an index. We will use the method .merge() for Dataframes. It takes a Dataframe to merge with as the required input argument. The method looks for a common index column between the two dataframes and merge based on that index. merged = metadata.merge(expression) It’s usually better to specify what that index column to avoid ambiguity, using the on optional argument: merged = metadata.merge(expression, on=&#39;ModelID&#39;) If the index column for the two Dataframes are named differently, you can specify the column name for each Dataframe: merged = metadata.merge(expression, left_on=&#39;ModelID&#39;, right_on=&#39;ModelID&#39;) One of the most import checks you should do when merging dataframes is to look at the number of rows and columns before and after merging to see whether it makes sense or not: The number of rows and columns of metadata: metadata.shape ## (1864, 31) The number of rows and columns of expression: expression.shape ## (1450, 538) The number of rows and columns of merged: merged.shape ## (1450, 568) We see that the number of columns in merged combines the number of columns in metadata and expression, while the number of rows in merged is the smaller of the number of rows in metadata and expression: it only keeps rows that are found in both Dataframe’s index columns. This kind of join is called “inner join”, because in the Venn Diagram of elements common in both index column, we keep the inner overlap: You can specifiy the join style by changing the optional input argument how. how = \"outer\" keeps all observations - also known as a “full join” how = \"left\" keeps all observations in the left Dataframe. how = \"right\" keeps all observations in the right Dataframe. how = \"inner\" keeps observations common to both Dataframe. This is the default value of how. 4.3 Grouping and summarizing Dataframes In a dataset, there may be groups of observations that we want to understand, such as case vs. control, or comparing different cancer subtypes. For example, in metadata, the observation is cell lines, and perhaps we want to group cell lines into their respective cancer type, OncotreeLineage, and look at the mean age for each cancer type. We want to take metadata: ModelID OncotreeLineage Age “ACH-001113” “Lung” 69 “ACH-001289” “Lung” 23 “ACH-001339” “Skin” 14 “ACH-002342” “Brain” 23 “ACH-004854” “Brain” 56 “ACH-002921” “Brain” 67 into: OncotreeLineage MeanAge “Lung” 46 “Skin” 14 “Brain” 48.67 To get there, we need to: Group the data based on some criteria, elements of OncotreeLineage Summarize each group via a summary statistic performed on a column, such as Age. We first subset the the two columns we need, and then use the methods .group_by(x) and .mean(). metadata_grouped = metadata.groupby(&quot;OncotreeLineage&quot;) metadata_grouped[&#39;Age&#39;].mean() ## OncotreeLineage ## Adrenal Gland 55.000000 ## Ampulla of Vater 65.500000 ## Biliary Tract 58.450000 ## Bladder/Urinary Tract 65.166667 ## Bone 20.854545 ## Bowel 58.611111 ## Breast 50.961039 ## CNS/Brain 43.849057 ## Cervix 47.136364 ## Esophagus/Stomach 57.855556 ## Eye 51.100000 ## Fibroblast 38.194444 ## Head and Neck 60.149254 ## Kidney 46.193548 ## Liver 43.928571 ## Lung 55.444444 ## Lymphoid 38.916667 ## Myeloid 38.810811 ## Normal 52.370370 ## Other 46.000000 ## Ovary/Fallopian Tube 51.980769 ## Pancreas 60.226415 ## Peripheral Nervous System 5.480000 ## Pleura 61.000000 ## Prostate 61.666667 ## Skin 49.033708 ## Soft Tissue 27.500000 ## Testis 25.000000 ## Thyroid 63.235294 ## Uterus 62.060606 ## Vulva/Vagina 75.400000 ## Name: Age, dtype: float64 Here’s what’s going on: We use the Dataframe method .group_by(x) and specify the column we want to group by. The output of this method is a Grouped Dataframe object. It still contains all the information of the metadata Dataframe, but it makes a note that it’s been grouped. We subset to the column Age. The grouping information still persists (This is a Grouped Series object). We use the method .mean() to calculate the mean value of Age within each group defined by OncotreeLineage. Alternatively, this could have been done in a chain of methods: metadata.groupby(&quot;OncotreeLineage&quot;)[&quot;Age&quot;].mean() ## OncotreeLineage ## Adrenal Gland 55.000000 ## Ampulla of Vater 65.500000 ## Biliary Tract 58.450000 ## Bladder/Urinary Tract 65.166667 ## Bone 20.854545 ## Bowel 58.611111 ## Breast 50.961039 ## CNS/Brain 43.849057 ## Cervix 47.136364 ## Esophagus/Stomach 57.855556 ## Eye 51.100000 ## Fibroblast 38.194444 ## Head and Neck 60.149254 ## Kidney 46.193548 ## Liver 43.928571 ## Lung 55.444444 ## Lymphoid 38.916667 ## Myeloid 38.810811 ## Normal 52.370370 ## Other 46.000000 ## Ovary/Fallopian Tube 51.980769 ## Pancreas 60.226415 ## Peripheral Nervous System 5.480000 ## Pleura 61.000000 ## Prostate 61.666667 ## Skin 49.033708 ## Soft Tissue 27.500000 ## Testis 25.000000 ## Thyroid 63.235294 ## Uterus 62.060606 ## Vulva/Vagina 75.400000 ## Name: Age, dtype: float64 Once a Dataframe has been grouped and a column is selected, all the summary statistics methods you learned from last week, such as .mean(), .median(), .max(), can be used. One new summary statistics method that is useful for this grouping and summarizing analysis is .count() which tells you how many entries are counted within each group. 4.3.1 Optional: Multiple grouping, Multiple columns, Multiple summary statistics Sometimes, when performing grouping and summary analysis, you want to operate on multiple columns simultaneously. For example, you may want to group by a combination of OncotreeLineage and AgeCategory, such as “Lung” and “Adult” as one grouping. You can do so like this: metadata_grouped = metadata.groupby([&quot;OncotreeLineage&quot;, &quot;AgeCategory&quot;]) metadata_grouped[&#39;Age&#39;].mean() ## OncotreeLineage AgeCategory ## Adrenal Gland Adult 55.000000 ## Ampulla of Vater Adult 65.500000 ## Unknown NaN ## Biliary Tract Adult 58.450000 ## Unknown NaN ## ... ## Thyroid Unknown NaN ## Uterus Adult 62.060606 ## Fetus NaN ## Unknown NaN ## Vulva/Vagina Adult 75.400000 ## Name: Age, Length: 72, dtype: float64 You can also summarize on multiple columns simultaneously. For each column, you have to specify what summary statistic functions you want to use. This can be specified via the .agg(x) method on a Grouped Dataframe. For example, coming back to our age case-control Dataframe, df = pd.DataFrame(data={&#39;status&#39;: [&quot;treated&quot;, &quot;untreated&quot;, &quot;untreated&quot;, &quot;discharged&quot;, &quot;treated&quot;], &#39;age_case&#39;: [25, 43, 21, 65, 7], &#39;age_control&#39;: [49, 20, 32, 25, 32]}) df ## status age_case age_control ## 0 treated 25 49 ## 1 untreated 43 20 ## 2 untreated 21 32 ## 3 discharged 65 25 ## 4 treated 7 32 We group by status and summarize age_case and age_control with a few summary statistics each: df.groupby(&quot;status&quot;).agg({&quot;age_case&quot;: &quot;mean&quot;, &quot;age_control&quot;: [&quot;min&quot;, &quot;max&quot;, &quot;mean&quot;]}) ## age_case age_control ## mean min max mean ## status ## discharged 65.0 25 25 25.0 ## treated 16.0 32 49 40.5 ## untreated 32.0 20 32 26.0 The input argument to the .agg(x) method is called a Dictionary, which let’s you structure information in a paired relationship. You can learn more about dictionaries here. 4.4 Exercises Exercise for week 4 can be found here. "],["data-visualization.html", "Chapter 5 Data Visualization 5.1 Distributions (one variable) 5.2 Relational (between 2 continuous variables) 5.3 Categorical (between 1 categorical and 1 continuous variable) 5.4 Basic plot customization 5.5 Exercises", " Chapter 5 Data Visualization In our final to last week together, we learn about how to visualize our data. There are several different data visualization modules in Python: matplotlib is a general purpose plotting module that is commonly used. seaborn is a plotting module built on top of matplotlib focused on data science and statistical visualization. We will focus on this module for this course. plotnine is a plotting module based on the grammar of graphics organization of making plots. This is very similar to the R package “ggplot”. To get started, we will consider these most simple and common plots: Distributions (one variable) Histograms Relational (between 2 continuous variables) Scatterplots Line plots Categorical (between 1 categorical and 1 continuous variable) Bar plots Violin plots Why do we focus on these common plots? Our eyes are better at distinguishing certain visual features more than others. All of these plots are focused on their position to depict data, which gives us the most effective visual scale. Let’s load in our genomics datasets and start making some plots from them. import pandas as pd import seaborn as sns import matplotlib.pyplot as plt metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) mutation = pd.read_csv(&quot;classroom_data/mutation.csv&quot;) expression = pd.read_csv(&quot;classroom_data/expression.csv&quot;) 5.1 Distributions (one variable) To create a histogram, we use the function sns.displot() and we specify the input argument data as our dataframe, and the input argument x as the column name in a String. plot = sns.displot(data=metadata, x=&quot;Age&quot;) (For the webpage’s purpose, assign the plot to a variable plot. In practice, you don’t need to do that. You can just write sns.displot(data=metadata, x=\"Age\")). A common parameter to consider when making histogram is how big the bins are. You can specify the bin width via binwidth argument, or the number of bins via bins argument. plot = sns.displot(data=metadata, x=&quot;Age&quot;, binwidth = 10) Our histogram also works for categorical variables, such as “Sex”. plot = sns.displot(data=metadata, x=&quot;Sex&quot;) Conditioning on other variables Sometimes, you want to examine a distribution, such as Age, conditional on other variables, such as Age for Female, Age for Male, and Age for Unknown: what is the distribution of age when compared with sex? There are several ways of doing it. First, you could color variables by color, using the hue input argument: plot = sns.displot(data=metadata, x=&quot;Age&quot;, hue=&quot;Sex&quot;) It is rather hard to tell the groups apart from the coloring. So, we add a new option that we want to separate each bar category via multiple=\"dodge\" input argument: plot = sns.displot(data=metadata, x=&quot;Age&quot;, hue=&quot;Sex&quot;, multiple=&quot;dodge&quot;) Lastly, an alternative to using colors to display the conditional variable, we could make a subplot for each conditional variable’s value via col=\"Sex\" or row=\"Sex\": plot = sns.displot(data=metadata, x=&quot;Age&quot;, col=&quot;Sex&quot;) You can find a lot more details about distributions and histograms in the Seaborn tutorial. 5.2 Relational (between 2 continuous variables) To visualize two continuous variables, it is common to use a scatterplot or a lineplot. We use the function sns.relplot() and we specify the input argument data as our dataframe, and the input arguments x and y as the column names in a String: plot = sns.relplot(data=expression, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;) To conditional on other variables, plotting features are used to distinguish conditional variable values: hue (similar to the histogram) style size Let’s merge expression and metadata together, so that we can examine KRAS and EGFR relationships conditional on primary vs. metastatic cancer status. Here is the scatterplot with different color: expression_metadata = expression.merge(metadata) plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, hue=&quot;PrimaryOrMetastasis&quot;) Here is the scatterplot with different shapes: plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, style=&quot;PrimaryOrMetastasis&quot;) You can also try plotting with size=PrimaryOrMetastasis\" if you like. None of these seem pretty effective at distinguishing the two groups, so we will try subplot faceting as we did for the histogram: plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, col=&quot;PrimaryOrMetastasis&quot;) You can also conditional on multiple variables by assigning a different variable to the conditioning options: plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, hue=&quot;PrimaryOrMetastasis&quot;, col=&quot;AgeCategory&quot;) You can find a lot more details about relational plots such as scatterplots and lineplots in the Seaborn tutorial. 5.3 Categorical (between 1 categorical and 1 continuous variable) A very similar pattern follows for categorical plots. We start with sns.catplot() as our main plotting function, with the basic input arguments: data x y You can change the plot styles via the input arguments: kind: “strip”, “box”, “swarm”, etc. You can add additional conditional variables via the input arguments: hue col row See categorical plots in the Seaborn tutorial. 5.4 Basic plot customization You can easily change the axis labels and title if you modify the plot object, using the method .set(): exp_plot = sns.relplot(data=expression, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;) exp_plot.set(xlabel=&quot;KRAS Espression&quot;, ylabel=&quot;EGFR Expression&quot;, title=&quot;Gene expression relationship&quot;) You can change the color palette by setting adding the palette input argument to any of the plots. You can explore available color palettes here: plot = sns.displot(data=metadata, x=&quot;Age&quot;, hue=&quot;Sex&quot;, multiple=&quot;dodge&quot;, palette=sns.color_palette(palette=&#39;rainbow&#39;) ) ## &lt;string&gt;:1: UserWarning: The palette list has more values (6) than needed (3), which may not be intended. 5.5 Exercises Exercise for week 5 can be found here. "],["about-the-authors.html", "About the Authors", " About the Authors These credits are based on our course contributors table guidelines.     Credits Names Pedagogy Lead Content Instructor(s) FirstName LastName Lecturer(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved Delivered the course in some way - video or audio Content Author(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved If any other authors besides lead instructor Content Contributor(s) (include section name/link in parentheses) - make new line if more than one section involved Wrote less than a chapter Content Editor(s)/Reviewer(s) Checked your content Content Director(s) Helped guide the content direction Content Consultants (include chapter name/link in parentheses or word “General”) - make new line if more than one chapter involved Gave high level advice on content Acknowledgments Gave small assistance to content but not to the level of consulting Production Content Publisher(s) Helped with publishing platform Content Publishing Reviewer(s) Reviewed overall content and aesthetics on publishing platform Technical Course Publishing Engineer(s) Helped with the code for the technical aspects related to the specific course generation Template Publishing Engineers Candace Savonen, Carrie Wright, Ava Hoffman Publishing Maintenance Engineer Candace Savonen Technical Publishing Stylists Carrie Wright, Ava Hoffman, Candace Savonen Package Developers (ottrpal) Candace Savonen, John Muschelli, Carrie Wright Art and Design Illustrator(s) Created graphics for the course Figure Artist(s) Created figures/plots for course Videographer(s) Filmed videos Videography Editor(s) Edited film Audiographer(s) Recorded audio Audiography Editor(s) Edited audio recordings Funding Funder(s) Institution/individual who funded course including grant number Funding Staff Staff members who help with funding   ## ─ Session info ─────────────────────────────────────────────────────────────── ## setting value ## version R version 4.3.2 (2023-10-31) ## os Ubuntu 22.04.4 LTS ## system x86_64, linux-gnu ## ui X11 ## language (EN) ## collate en_US.UTF-8 ## ctype en_US.UTF-8 ## tz Etc/UTC ## date 2024-09-26 ## pandoc 3.1.1 @ /usr/local/bin/ (via rmarkdown) ## ## ─ Packages ─────────────────────────────────────────────────────────────────── ## package * version date (UTC) lib source ## askpass 1.2.0 2023-09-03 [1] RSPM (R 4.3.0) ## bookdown 0.39.1 2024-06-11 [1] Github (rstudio/bookdown@f244cf1) ## bslib 0.6.1 2023-11-28 [1] RSPM (R 4.3.0) ## cachem 1.0.8 2023-05-01 [1] RSPM (R 4.3.0) ## cli 3.6.2 2023-12-11 [1] RSPM (R 4.3.0) ## devtools 2.4.5 2022-10-11 [1] RSPM (R 4.3.0) ## digest 0.6.34 2024-01-11 [1] RSPM (R 4.3.0) ## ellipsis 0.3.2 2021-04-29 [1] RSPM (R 4.3.0) ## evaluate 0.23 2023-11-01 [1] RSPM (R 4.3.0) ## fansi 1.0.6 2023-12-08 [1] RSPM (R 4.3.0) ## fastmap 1.1.1 2023-02-24 [1] RSPM (R 4.3.0) ## fs 1.6.3 2023-07-20 [1] RSPM (R 4.3.0) ## glue 1.7.0 2024-01-09 [1] RSPM (R 4.3.0) ## hms 1.1.3 2023-03-21 [1] RSPM (R 4.3.0) ## htmltools 0.5.7 2023-11-03 [1] RSPM (R 4.3.0) ## htmlwidgets 1.6.4 2023-12-06 [1] RSPM (R 4.3.0) ## httpuv 1.6.14 2024-01-26 [1] RSPM (R 4.3.0) ## httr 1.4.7 2023-08-15 [1] RSPM (R 4.3.0) ## jquerylib 0.1.4 2021-04-26 [1] RSPM (R 4.3.0) ## jsonlite 1.8.8 2023-12-04 [1] RSPM (R 4.3.0) ## knitr 1.47.3 2024-06-11 [1] Github (yihui/knitr@e1edd34) ## later 1.3.2 2023-12-06 [1] RSPM (R 4.3.0) ## lifecycle 1.0.4 2023-11-07 [1] RSPM (R 4.3.0) ## magrittr 2.0.3 2022-03-30 [1] RSPM (R 4.3.0) ## memoise 2.0.1 2021-11-26 [1] RSPM (R 4.3.0) ## mime 0.12 2021-09-28 [1] RSPM (R 4.3.0) ## miniUI 0.1.1.1 2018-05-18 [1] RSPM (R 4.3.0) ## openssl 2.1.1 2023-09-25 [1] RSPM (R 4.3.0) ## ottrpal 1.2.1 2024-06-11 [1] Github (jhudsl/ottrpal@828539f) ## pillar 1.9.0 2023-03-22 [1] RSPM (R 4.3.0) ## pkgbuild 1.4.3 2023-12-10 [1] RSPM (R 4.3.0) ## pkgconfig 2.0.3 2019-09-22 [1] RSPM (R 4.3.0) ## pkgload 1.3.4 2024-01-16 [1] RSPM (R 4.3.0) ## profvis 0.3.8 2023-05-02 [1] RSPM (R 4.3.0) ## promises 1.2.1 2023-08-10 [1] RSPM (R 4.3.0) ## purrr 1.0.2 2023-08-10 [1] RSPM (R 4.3.0) ## R6 2.5.1 2021-08-19 [1] RSPM (R 4.3.0) ## Rcpp 1.0.12 2024-01-09 [1] RSPM (R 4.3.0) ## readr 2.1.5 2024-01-10 [1] RSPM (R 4.3.0) ## remotes 2.4.2.1 2023-07-18 [1] RSPM (R 4.3.0) ## rlang 1.1.4 2024-06-04 [1] CRAN (R 4.3.2) ## rmarkdown 2.27.1 2024-06-11 [1] Github (rstudio/rmarkdown@e1c93a9) ## sass 0.4.8 2023-12-06 [1] RSPM (R 4.3.0) ## sessioninfo 1.2.2 2021-12-06 [1] RSPM (R 4.3.0) ## shiny 1.8.0 2023-11-17 [1] RSPM (R 4.3.0) ## stringi 1.8.3 2023-12-11 [1] RSPM (R 4.3.0) ## stringr 1.5.1 2023-11-14 [1] RSPM (R 4.3.0) ## tibble 3.2.1 2023-03-20 [1] CRAN (R 4.3.2) ## tzdb 0.4.0 2023-05-12 [1] RSPM (R 4.3.0) ## urlchecker 1.0.1 2021-11-30 [1] RSPM (R 4.3.0) ## usethis 2.2.3 2024-02-19 [1] RSPM (R 4.3.0) ## utf8 1.2.4 2023-10-22 [1] RSPM (R 4.3.0) ## vctrs 0.6.5 2023-12-01 [1] RSPM (R 4.3.0) ## xfun 0.44.4 2024-06-11 [1] Github (yihui/xfun@9da62cc) ## xml2 1.3.6 2023-12-04 [1] RSPM (R 4.3.0) ## xtable 1.8-4 2019-04-21 [1] RSPM (R 4.3.0) ## yaml 2.3.8 2023-12-11 [1] RSPM (R 4.3.0) ## ## [1] /usr/local/lib/R/site-library ## [2] /usr/local/lib/R/library ## ## ────────────────────────────────────────────────────────────────────────────── "],["references.html", "Chapter 6 References", " Chapter 6 References "],["404.html", "Page not found", " Page not found The page you requested cannot be found (perhaps it was moved or renamed). You may want to try searching to find the page's new location, or use the table of contents to find the page you are looking for. "]]
diff --git a/docs/no_toc/working-with-data-structures.html b/docs/no_toc/working-with-data-structures.html
new file mode 100644
index 0000000..9cb49e5
--- /dev/null
+++ b/docs/no_toc/working-with-data-structures.html
@@ -0,0 +1,603 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 2 Working with data structures | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 2 Working with data structures | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 2 Working with data structures | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="intro-to-computing.html"/>
+<link rel="next" href="data-wrangling-part-1.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="working-with-data-structures" class="section level1 hasAnchor" number="2">
+<h1><span class="header-section-number">Chapter 2</span> Working with data structures<a href="working-with-data-structures.html#working-with-data-structures" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>In our second lesson, we start to look at two <strong>data structures</strong>, <strong>Lists</strong> and <strong>Dataframes</strong>, that can handle a large amount of data for analysis.</p>
+<div id="lists" class="section level2 hasAnchor" number="2.1">
+<h2><span class="header-section-number">2.1</span> Lists<a href="working-with-data-structures.html#lists" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>In the first exercise, you started to explore <strong>data structures</strong>, which store information about data types. You explored <strong>lists</strong>, which is an ordered collection of data types or data structures. Each <em>element</em> of a list contains a data type or another data structure.</p>
+<p>We can now store a vast amount of information in a list, and assign it to a single variable. Even more, we can use operations and functions on a list, modifying many elements within the list at once! This makes analyzing data much more scalable and less repetitive.</p>
+<p>We create a list via the bracket <code>[ ]</code> operation.</p>
+<div class="sourceCode" id="cb36"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb36-1"><a href="working-with-data-structures.html#cb36-1" tabindex="-1"></a>staff <span class="op">=</span> [<span class="st">&quot;chris&quot;</span>, <span class="st">&quot;ted&quot;</span>, <span class="st">&quot;jeff&quot;</span>]</span>
+<span id="cb36-2"><a href="working-with-data-structures.html#cb36-2" tabindex="-1"></a>chrNum <span class="op">=</span> [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">2</span>]</span>
+<span id="cb36-3"><a href="working-with-data-structures.html#cb36-3" tabindex="-1"></a>mixedList <span class="op">=</span> [<span class="va">False</span>, <span class="va">False</span>, <span class="va">False</span>, <span class="st">&quot;A&quot;</span>, <span class="st">&quot;B&quot;</span>, <span class="dv">92</span>]</span></code></pre></div>
+<div id="subsetting-lists" class="section level3 hasAnchor" number="2.1.1">
+<h3><span class="header-section-number">2.1.1</span> Subsetting lists<a href="working-with-data-structures.html#subsetting-lists" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>To access an element of a list, you can use the bracket notation <code>[ ]</code> to access the elements of the list. We simply access an element via the “index” number - the location of the data within the list.</p>
+<p><em>Here’s the tricky thing about the index number: it starts at 0!</em></p>
+<p>1st element of <code>chrNum</code>: <code>chrNum[0]</code></p>
+<p>2nd element of <code>chrNum</code>: <code>chrNum[1]</code></p>
+<p>…</p>
+<p>5th element of <code>chrNum</code>: <code>chrNum[4]</code></p>
+<p>With subsetting, you can modify elements of a list or use the element of a list as part of an expression.</p>
+</div>
+<div id="subsetting-multiple-elements-of-lists" class="section level3 hasAnchor" number="2.1.2">
+<h3><span class="header-section-number">2.1.2</span> Subsetting multiple elements of lists<a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>Suppose you want to access multiple elements of a list, such as accessing the first three elements of <code>chrNum</code>. You would use the <strong>slice</strong> operator <code>:</code>, which specifies:</p>
+<ul>
+<li><p>the index number to start</p></li>
+<li><p>the index number to stop, <em>plus one.</em></p></li>
+</ul>
+<p>If you want to access the first three elements of <code>chrNum</code>:</p>
+<div class="sourceCode" id="cb37"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb37-1"><a href="working-with-data-structures.html#cb37-1" tabindex="-1"></a>chrNum[<span class="dv">0</span>:<span class="dv">3</span>]</span></code></pre></div>
+<pre><code>## [2, 3, 1]</code></pre>
+<p>The first element’s index number is 0, the third element’s index number is 2, plus 1, which is 3.</p>
+<p>If you want to access the second and third elements of <code>chrNum</code>:</p>
+<div class="sourceCode" id="cb39"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb39-1"><a href="working-with-data-structures.html#cb39-1" tabindex="-1"></a>chrNum[<span class="dv">1</span>:<span class="dv">3</span>]</span></code></pre></div>
+<pre><code>## [3, 1]</code></pre>
+<p>Another way of accessing the first 3 elements of <code>chrNum</code>:</p>
+<div class="sourceCode" id="cb41"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb41-1"><a href="working-with-data-structures.html#cb41-1" tabindex="-1"></a>chrNum[:<span class="dv">3</span>]</span></code></pre></div>
+<pre><code>## [2, 3, 1]</code></pre>
+<p>Here, the start index number was not specified. When the start or stop index is <em>not</em> specified, it implies that you are subsetting starting the from the beginning of the list or subsetting to the end of the list, respectively. Here’s another example, using negative indicies to count from 3 elements from the end of the list:</p>
+<div class="sourceCode" id="cb43"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb43-1"><a href="working-with-data-structures.html#cb43-1" tabindex="-1"></a>chrNum[<span class="op">-</span><span class="dv">3</span>:]</span></code></pre></div>
+<pre><code>## [1, 2, 2]</code></pre>
+<p>You can find more discussion of list slicing, using negative indicies and incremental slicing, <a href="https://towardsdatascience.com/the-basics-of-indexing-and-slicing-python-lists-2d12c90a94cf">here</a>.</p>
+</div>
+</div>
+<div id="objects-in-python" class="section level2 hasAnchor" number="2.2">
+<h2><span class="header-section-number">2.2</span> Objects in Python<a href="working-with-data-structures.html#objects-in-python" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>The list data structure has an organization and functionality that metaphorically represents a pen-and-paper list in our physical world. Like a physical object, we have examined:</p>
+<ul>
+<li><p>What does it contain (in terms of data)?</p></li>
+<li><p>What can it do (in terms of functions)?</p></li>
+</ul>
+<p>And if it “makes sense” to us, then it is well-designed.</p>
+<p>The list data structure we have been working with is an example of an <strong>Object</strong>. The definition of an object allows us to ask the questions above: <em>what does it contain, and what can it do?</em> It is an organizational tool for a collection of data and functions that we can relate to, like a physical object. Formally, an object contains the following:</p>
+<ul>
+<li><p><strong>Value</strong> that holds the essential data for the object.</p></li>
+<li><p><strong>Attributes</strong> that hold subset or additional data for the object.</p></li>
+<li><p>Functions called <strong>Methods</strong> that are for the object and <em>have to</em> take in the variable referenced as an input</p></li>
+</ul>
+<p>This organizing structure on an object applies to pretty much all Python data types and data structures.</p>
+<p>Let’s see how this applies to the list:</p>
+<ul>
+<li><p><strong>Value</strong>: the contents of the list, such as <code>[2, 3, 4].</code></p></li>
+<li><p><strong>Attributes</strong> that store additional values: Not relevant for lists.</p></li>
+<li><p><strong>Methods</strong> that can be used on the object: <code>chrNum.count(2)</code> counts the number of instances 2 appears as an element of <code>chrNum</code>.</p></li>
+</ul>
+<p>Object methods are functions that does something with the object you are using it on. You should think about <code>chrNum.count(2)</code> as a function that takes in <code>chrNum</code> and <code>2</code> as inputs. If you want to use the count function on list <code>mixedList</code>, you would use <code>mixedList.count(x)</code>.</p>
+<p>Here are some more examples of methods with lists:</p>
+<table>
+<colgroup>
+<col width="20%" />
+<col width="20%" />
+<col width="37%" />
+<col width="20%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Function method</th>
+<th>What it takes in</th>
+<th>What it does</th>
+<th>Returns</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.count(x)</code></a></td>
+<td>list <code>chrNum</code>, data type <code>x</code></td>
+<td>Counts the number of instances <code>x</code> appears as an element of <code>chrNum</code>.</td>
+<td>Integer</td>
+</tr>
+<tr class="even">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.append(x)</code></a></td>
+<td>list <code>chrNum</code>, data type <code>x</code></td>
+<td>Appends <code>x</code> to the end of the <code>chrNum</code>.</td>
+<td>None (but <code>chrNum</code> is modified!)</td>
+</tr>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.sort()</code></a></td>
+<td>list <code>chrNum</code></td>
+<td>Sorts <code>chrNum</code> by ascending order.</td>
+<td>None (but <code>chrNum</code> is modified!)</td>
+</tr>
+<tr class="even">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.reverse()</code></a></td>
+<td>list <code>chrNum</code></td>
+<td>Reverses the order of <code>chrNum</code>.</td>
+<td>None (but <code>chrNum</code> is modified!)</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div id="methods-vs-functions" class="section level2 hasAnchor" number="2.3">
+<h2><span class="header-section-number">2.3</span> Methods vs Functions<a href="working-with-data-structures.html#methods-vs-functions" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p><strong>Methods</strong> <em>have to</em> take in the object of interest as an input: <code>chrNum.count(2)</code> automatically treat <code>chrNum</code> as an input. Methods are built for a specific Object type.</p>
+<p><strong>Functions</strong> do not have an implied input: <code>len(chrNum)</code> requires specifying a list in the input.</p>
+<p>Otherwise, there is no strong distinction between the two.</p>
+</div>
+<div id="dataframes" class="section level2 hasAnchor" number="2.4">
+<h2><span class="header-section-number">2.4</span> Dataframes<a href="working-with-data-structures.html#dataframes" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>A Dataframe is a two-dimensional data structure that stores data like a spreadsheet does.</p>
+<p>The Dataframe data structure is found within a Python module called “Pandas”. A Python module is an organized collection of functions and data structures. The <code>import</code> statement below gives us permission to access the “Pandas” module via the variable <code>pd</code>.</p>
+<p>To load in a Dataframe from existing spreadsheet data, we use the function <a href="https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html"><code>pd.read_csv()</code></a>:</p>
+<div class="sourceCode" id="cb45"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb45-1"><a href="working-with-data-structures.html#cb45-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb45-2"><a href="working-with-data-structures.html#cb45-2" tabindex="-1"></a></span>
+<span id="cb45-3"><a href="working-with-data-structures.html#cb45-3" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb45-4"><a href="working-with-data-structures.html#cb45-4" tabindex="-1"></a><span class="bu">type</span>(metadata)</span></code></pre></div>
+<pre><code>## &lt;class &#39;pandas.core.frame.DataFrame&#39;&gt;</code></pre>
+<p>There is a similar function <a href="https://pandas.pydata.org/docs/reference/api/pandas.read_excel.html"><code>pd.read_excel()</code></a> for loading in Excel spreadsheets.</p>
+<p>Let’s investigate the Dataframe as an object:</p>
+<ul>
+<li><p>What does a Dataframe contain (values, attributes)?</p></li>
+<li><p>What can a Dataframe do (methods)?</p></li>
+</ul>
+</div>
+<div id="what-does-a-dataframe-contain" class="section level2 hasAnchor" number="2.5">
+<h2><span class="header-section-number">2.5</span> What does a Dataframe contain?<a href="working-with-data-structures.html#what-does-a-dataframe-contain" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>We first take a look at the contents:</p>
+<div class="sourceCode" id="cb47"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb47-1"><a href="working-with-data-structures.html#cb47-1" tabindex="-1"></a>metadata</span></code></pre></div>
+<pre><code>##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]</code></pre>
+<p>It looks like there are 1864 rows and 30 columns in this Dataframe, and when we display it it shows some of the data.</p>
+<div class="sourceCode" id="cb49"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb49-1"><a href="working-with-data-structures.html#cb49-1" tabindex="-1"></a>metadata</span></code></pre></div>
+<pre><code>##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]</code></pre>
+<p>We can look at specific columns by looking at <strong>attributes</strong> via the dot operation. We can also look at the columns via the bracket operation.</p>
+<div class="sourceCode" id="cb51"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb51-1"><a href="working-with-data-structures.html#cb51-1" tabindex="-1"></a>metadata.ModelID</span></code></pre></div>
+<pre><code>## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object</code></pre>
+<div class="sourceCode" id="cb53"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb53-1"><a href="working-with-data-structures.html#cb53-1" tabindex="-1"></a>metadata[<span class="st">&#39;ModelID&#39;</span>]</span></code></pre></div>
+<pre><code>## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object</code></pre>
+<p>The names of all columns is stored as an attribute, which can be accessed via the dot operation.</p>
+<div class="sourceCode" id="cb55"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb55-1"><a href="working-with-data-structures.html#cb55-1" tabindex="-1"></a>metadata.columns</span></code></pre></div>
+<pre><code>## Index([&#39;ModelID&#39;, &#39;PatientID&#39;, &#39;CellLineName&#39;, &#39;StrippedCellLineName&#39;, &#39;Age&#39;,
+##        &#39;SourceType&#39;, &#39;SangerModelID&#39;, &#39;RRID&#39;, &#39;DepmapModelType&#39;, &#39;AgeCategory&#39;,
+##        &#39;GrowthPattern&#39;, &#39;LegacyMolecularSubtype&#39;, &#39;PrimaryOrMetastasis&#39;,
+##        &#39;SampleCollectionSite&#39;, &#39;Sex&#39;, &#39;SourceDetail&#39;, &#39;LegacySubSubtype&#39;,
+##        &#39;CatalogNumber&#39;, &#39;CCLEName&#39;, &#39;COSMICID&#39;, &#39;PublicComments&#39;,
+##        &#39;WTSIMasterCellID&#39;, &#39;EngineeredModel&#39;, &#39;TreatmentStatus&#39;,
+##        &#39;OnboardedMedia&#39;, &#39;PlateCoating&#39;, &#39;OncotreeCode&#39;, &#39;OncotreeSubtype&#39;,
+##        &#39;OncotreePrimaryDisease&#39;, &#39;OncotreeLineage&#39;],
+##       dtype=&#39;object&#39;)</code></pre>
+<p>The number of rows and columns are also stored as an attribute:</p>
+<div class="sourceCode" id="cb57"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb57-1"><a href="working-with-data-structures.html#cb57-1" tabindex="-1"></a>metadata.shape</span></code></pre></div>
+<pre><code>## (1864, 30)</code></pre>
+</div>
+<div id="what-can-a-dataframe-do" class="section level2 hasAnchor" number="2.6">
+<h2><span class="header-section-number">2.6</span> What can a Dataframe do?<a href="working-with-data-structures.html#what-can-a-dataframe-do" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>We can use the <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.head.html"><code>.head()</code></a> and <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.tail.html"><code>.tail()</code></a> methods to look at the first few rows and last few rows of <code>metadata</code>, respectively:</p>
+<div class="sourceCode" id="cb59"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb59-1"><a href="working-with-data-structures.html#cb59-1" tabindex="-1"></a>metadata.head()</span></code></pre></div>
+<pre><code>##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]</code></pre>
+<div class="sourceCode" id="cb61"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb61-1"><a href="working-with-data-structures.html#cb61-1" tabindex="-1"></a>metadata.tail()</span></code></pre></div>
+<pre><code>##          ModelID  PatientID  ...          OncotreePrimaryDisease    OncotreeLineage
+## 1859  ACH-002968  PT-pjhrsc  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1860  ACH-002972  PT-dkXZB1  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1861  ACH-002979  PT-lyHTzo  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1862  ACH-002981  PT-Z9akXf  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1863  ACH-003071  PT-LAGmLq  ...       Lung Neuroendocrine Tumor               Lung
+## 
+## [5 rows x 30 columns]</code></pre>
+<p>Both of these functions (without input arguments) are considered as <strong>methods</strong>: they are functions that does something with the Dataframe you are using it on. You should think about <code>metadata.head()</code> as a function that takes in <code>metadata</code> as an input. If we had another Dataframe called <code>my_data</code> and you want to use the same function, you will have to say <code>my_data.head()</code>.</p>
+</div>
+<div id="subsetting-dataframes" class="section level2 hasAnchor" number="2.7">
+<h2><span class="header-section-number">2.7</span> Subsetting Dataframes<a href="working-with-data-structures.html#subsetting-dataframes" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Perhaps the most important operation you will can do with Dataframes is subsetting them. There are two ways to do it. The first way is to subset by numerical indicies, exactly like how we did for lists.</p>
+<p>You will use the <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html"><code>iloc</code></a> attribute and bracket operations, and you give two slices: one for the row, and one for the column.</p>
+<p>Let’s start with a small dataframe to see how it works before returning to <code>metadata</code>:</p>
+<div class="sourceCode" id="cb63"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb63-1"><a href="working-with-data-structures.html#cb63-1" tabindex="-1"></a>df <span class="op">=</span> pd.DataFrame(data<span class="op">=</span>{<span class="st">&#39;status&#39;</span>: [<span class="st">&quot;treated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;discharged&quot;</span>, <span class="st">&quot;treated&quot;</span>],</span>
+<span id="cb63-2"><a href="working-with-data-structures.html#cb63-2" tabindex="-1"></a>                            <span class="st">&#39;age_case&#39;</span>: [<span class="dv">25</span>, <span class="dv">43</span>, <span class="dv">21</span>, <span class="dv">65</span>, <span class="dv">7</span>],</span>
+<span id="cb63-3"><a href="working-with-data-structures.html#cb63-3" tabindex="-1"></a>                            <span class="st">&#39;age_control&#39;</span>: [<span class="dv">49</span>, <span class="dv">20</span>, <span class="dv">32</span>, <span class="dv">25</span>, <span class="dv">32</span>]})</span>
+<span id="cb63-4"><a href="working-with-data-structures.html#cb63-4" tabindex="-1"></a>df</span></code></pre></div>
+<pre><code>##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32</code></pre>
+<p>Here is how the dataframe looks like with the row and column index numbers:</p>
+<p><img src="images/pandas_subset_0.png" /></p>
+<p>Subset the first fourth rows, and the first two columns:</p>
+<p><img src="images/pandas%20subset_1.png" /></p>
+<p>Now, back to <code>metadata</code> dataframe:</p>
+<p>Subset the first 5 rows, and first two columns:</p>
+<div class="sourceCode" id="cb65"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb65-1"><a href="working-with-data-structures.html#cb65-1" tabindex="-1"></a>metadata.iloc[:<span class="dv">5</span>, :<span class="dv">2</span>]</span></code></pre></div>
+<pre><code>##       ModelID  PatientID
+## 0  ACH-000001  PT-gj46wT
+## 1  ACH-000002  PT-5qa3uk
+## 2  ACH-000003  PT-puKIyc
+## 3  ACH-000004  PT-q4K2cp
+## 4  ACH-000005  PT-q4K2cp</code></pre>
+<p>If we want a custom slice that is not sequential, we can use an integer list. Subset the last 5 rows, and the 1st and 10 and 21th column:</p>
+<div class="sourceCode" id="cb67"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb67-1"><a href="working-with-data-structures.html#cb67-1" tabindex="-1"></a>metadata.iloc[<span class="dv">5</span>:, [<span class="dv">1</span>, <span class="dv">10</span>, <span class="dv">21</span>]]</span></code></pre></div>
+<pre><code>##       PatientID GrowthPattern  WTSIMasterCellID
+## 5     PT-ej13Dz    Suspension            2167.0
+## 6     PT-NOXwpH      Adherent             569.0
+## 7     PT-fp8PeY      Adherent            1806.0
+## 8     PT-puKIyc      Adherent            2104.0
+## 9     PT-AR7W9o      Adherent               NaN
+## ...         ...           ...               ...
+## 1859  PT-pjhrsc      Organoid               NaN
+## 1860  PT-dkXZB1      Organoid               NaN
+## 1861  PT-lyHTzo      Organoid               NaN
+## 1862  PT-Z9akXf      Organoid               NaN
+## 1863  PT-LAGmLq    Suspension               NaN
+## 
+## [1859 rows x 3 columns]</code></pre>
+<p>When we subset via numerical indicies, it’s called <strong>explicit subsetting</strong>. This is a great way to start thinking about subsetting your dataframes for analysis, but explicit subsetting can lead to some inconsistencies in the long run. For instance, suppose your collaborator added a new cell line to the metadata and changed the order of the column. Then your code to subset the last 5 rows and the columns will get you a different answer once the spreadsheet is changed.</p>
+<p>The second way is to subset by the column name and comparison operators, also known as <strong>implicit subsetting</strong>. This is much more robust in data analysis practice. You will learn about it next week!</p>
+</div>
+<div id="exercises-1" class="section level2 hasAnchor" number="2.8">
+<h2><span class="header-section-number">2.8</span> Exercises<a href="working-with-data-structures.html#exercises-1" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 2 can be found <a href="https://colab.research.google.com/drive/1oIL3gKEZR2Lq16k6XY0HXIhjYl34pEjr?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="intro-to-computing.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-wrangling-part-1.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/docs/reference-keys.txt b/docs/reference-keys.txt
index d172de4..2bb8bd5 100644
--- a/docs/reference-keys.txt
+++ b/docs/reference-keys.txt
@@ -8,10 +8,44 @@ what-is-a-computer-program
 a-programming-language-has-following-elements
 google-colab-setup
 grammar-structure-1-evaluation-of-expressions
+function-machine-schema
 data-types
 grammar-structure-2-storing-data-types-in-the-variable-environment
 execution-rule-for-variable-assignment
 grammar-structure-3-evaluation-of-functions
 execution-rule-for-functions
 tips-on-writing-your-first-code
+exercises
+working-with-data-structures
+lists
+subsetting-lists
+subsetting-multiple-elements-of-lists
+objects-in-python
+methods-vs-functions
+dataframes
+what-does-a-dataframe-contain
+what-can-a-dataframe-do
+subsetting-dataframes
+exercises-1
+data-wrangling-part-1
+tidy-data
+our-working-tidy-data-depmap-project
+transform-what-do-you-want-to-do-with-this-dataframe
+lets-convert-our-implicit-subsetting-criteria-into-code
+summary-statistics
+simple-data-visualization
+chained-function-calls
+exercises-2
+data-wrangling-part-2
+creating-new-columns
+merging-two-dataframes-together
+grouping-and-summarizing-dataframes
+optional-multiple-grouping-multiple-columns-multiple-summary-statistics
+exercises-3
+data-visualization
+distributions-one-variable
+relational-between-2-continuous-variables
+categorical-between-1-categorical-and-1-continuous-variable
+basic-plot-customization
+exercises-4
 references
diff --git a/docs/references.html b/docs/references.html
index d03090c..7c34cff 100644
--- a/docs/references.html
+++ b/docs/references.html
@@ -4,18 +4,18 @@
 
   <meta charset="utf-8" />
   <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-  <title>Chapter 2 References | Introduction to Python</title>
+  <title>Chapter 6 References | Introduction to Python</title>
   <meta name="description" content="Description about Course/Book." />
   <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
 
-  <meta property="og:title" content="Chapter 2 References | Introduction to Python" />
+  <meta property="og:title" content="Chapter 6 References | Introduction to Python" />
   <meta property="og:type" content="book" />
   
   <meta property="og:description" content="Description about Course/Book." />
   
 
   <meta name="twitter:card" content="summary" />
-  <meta name="twitter:title" content="Chapter 2 References | Introduction to Python" />
+  <meta name="twitter:title" content="Chapter 6 References | Introduction to Python" />
   
   <meta name="twitter:description" content="Description about Course/Book." />
   
@@ -152,7 +152,8 @@
 <li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
 <li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
 <ul>
-<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.1</b> Data types</a></li>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
 </ul></li>
 <li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
 <ul>
@@ -163,9 +164,52 @@
 <li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
 </ul></li>
 <li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
 </ul></li>
 <li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
-<li class="chapter" data-level="2" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>2</b> References</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
 <li class="divider"></li>
 <p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
 <p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
@@ -200,8 +244,8 @@ <h1>
 <div class="hero-image-container"> 
   <img class= "hero-image" src="assets/dasl_thin_main_image.png">
 </div>
-<div id="references" class="section level1 hasAnchor" number="2">
-<h1><span class="header-section-number">Chapter 2</span> References<a href="references.html#references" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<div id="references" class="section level1 hasAnchor" number="6">
+<h1><span class="header-section-number">Chapter 6</span> References<a href="references.html#references" class="anchor-section" aria-label="Anchor link to header"></a></h1>
 
 </div>
 <hr>
diff --git a/docs/resources/images/02-chapter_of_course_files/figure-html/1YmwKdIy9BeQ3EShgZhvtb3MgR8P6iDX4DfFD65W_gdQ_gcc4fbee202_0_141.png b/docs/resources/images/02-chapter_of_course_files/figure-html/1YmwKdIy9BeQ3EShgZhvtb3MgR8P6iDX4DfFD65W_gdQ_gcc4fbee202_0_141.png
deleted file mode 100644
index b865852..0000000
Binary files a/docs/resources/images/02-chapter_of_course_files/figure-html/1YmwKdIy9BeQ3EShgZhvtb3MgR8P6iDX4DfFD65W_gdQ_gcc4fbee202_0_141.png and /dev/null differ
diff --git a/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png
new file mode 100644
index 0000000..30316b9
Binary files /dev/null and b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-11-1.png differ
diff --git a/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png
new file mode 100644
index 0000000..791e0d8
Binary files /dev/null and b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-12-3.png differ
diff --git a/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png
new file mode 100644
index 0000000..9ef4a07
Binary files /dev/null and b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-13-5.png differ
diff --git a/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png
new file mode 100644
index 0000000..9ef4a07
Binary files /dev/null and b/docs/resources/images/03-data-wrangling1_files/figure-html/unnamed-chunk-14-7.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png
new file mode 100644
index 0000000..8d60f0b
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-10-15.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png
new file mode 100644
index 0000000..bcb02b5
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-11-17.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png
new file mode 100644
index 0000000..c28c19e
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-12-19.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png
new file mode 100644
index 0000000..955505c
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-13-21.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png
new file mode 100644
index 0000000..b48141d
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-23.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png
new file mode 100644
index 0000000..7448370
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-14-24.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png
new file mode 100644
index 0000000..b3ce476
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-15-27.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png
new file mode 100644
index 0000000..03f4cec
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-3-1.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png
new file mode 100644
index 0000000..c637f45
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-4-3.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png
new file mode 100644
index 0000000..2fc750a
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-5-5.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png
new file mode 100644
index 0000000..cdffe6b
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-6-7.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png
new file mode 100644
index 0000000..f59f40d
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-7-9.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png
new file mode 100644
index 0000000..c9ffa6f
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-8-11.png differ
diff --git a/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png
new file mode 100644
index 0000000..b82f5a0
Binary files /dev/null and b/docs/resources/images/05-data-visualization_files/figure-html/unnamed-chunk-9-13.png differ
diff --git a/docs/search_index.json b/docs/search_index.json
index 52d469e..3650bd2 100644
--- a/docs/search_index.json
+++ b/docs/search_index.json
@@ -1 +1 @@
-[["index.html", "Introduction to Python About this Course 0.1 Curriculum 0.2 Target Audience 0.3 Learning Objectives 0.4 Offerings", " Introduction to Python August, 2024 About this Course 0.1 Curriculum The course covers fundamentals of Python, a high-level programming language, and use it to wrangle data for analysis and visualization. 0.2 Target Audience The course is intended for researchers who want to learn coding for the first time with a data science application via the Python language. This course is also appropriate for folks who have explored data science or programming on their own and want to focus on some fundamentals. 0.3 Learning Objectives Analyze Tidy datasets in the Python programming language via data subsetting, joining, and transformations. Evaluate summary statistics and data visualization to understand scientific questions. Describe how the Python programming environment interpret complex expressions made out of functions, operations, and data structures, in a step-by-step way. Apply problem solving strategies to debug broken code. 0.4 Offerings This course is taught on a regular basis at Fred Hutch Cancer Center through the Data Science Lab. Announcements of course offering can be found here. "],["intro-to-computing.html", "Chapter 1 Intro to Computing 1.1 Goals of the course 1.2 What is a computer program? 1.3 A programming language has following elements: 1.4 Google Colab Setup 1.5 Grammar Structure 1: Evaluation of Expressions 1.6 Grammar Structure 2: Storing data types in the Variable Environment 1.7 Grammar Structure 3: Evaluation of Functions 1.8 Tips on writing your first code", " Chapter 1 Intro to Computing Welcome to Introduction to Python! Each week, we cover a chapter, which consists of a lesson and exercise. In our first week together, we will look at big conceptual themes in programming, see how code is run, and learn some basic grammar structures of programming. 1.1 Goals of the course In the next 6 weeks, we will explore: Fundamental concepts in high-level programming languages (Python, R, Julia, etc.) that is transferable: How do programs run, and how do we solve problems using functions and data structures? Beginning of data science fundamentals: How do you translate your scientific question to a data wrangling problem and answer it? Data science workflow. Image source: R for Data Science. Find a nice balance between the two throughout the course: we will try to reproduce a figure from a scientific publication using new data. 1.2 What is a computer program? A sequence of instructions to manipulate data for the computer to execute. A series of translations: English &lt;-&gt; Programming Code for Interpreter &lt;-&gt; Machine Code for Central Processing Unit (CPU) We will focus on English &lt;-&gt; Programming Code for Python Interpreter in this class. More importantly: How we organize ideas &lt;-&gt; Instructing a computer to do something. 1.3 A programming language has following elements: Grammar structure to construct expressions; combining expressions to create more complex expressions Encapsulate complex expressions via functions to create modular and reusable tasks Encapsulate complex data via data structures to allow efficient manipulation of data 1.4 Google Colab Setup Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user. Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, open up… Today, we will pay close attention to: Python Console (Execution): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you. Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text and Python code, and it helps us understand better the code we are writing. Variable Environment: Open it by clicking on the “{x}” button on the left-hand panel. Often, your code will store information in the Variable Environment, so that information can be reused. For instance, we often load in data and store it in the Variable Environment, and use it throughout rest of your Python code. The first thing we will do is see the different ways we can run Python code. You can do the following: Type something into the Python Console (Execution) and type enter, such as 2+2. The Python Console will run it and give you an output. Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data. Run every single Python code chunk via Runtime -&gt; Run all. Remember that the order that you run your code matters in programming. Your final product would be the result of Option 3, in which you run every Python code chunk from start to finish. However, sometimes it is nice to try out smaller parts of your code via Options 1 or 2. But you will be at risk of running your code out of order! To create your own content in the notebook, click on a section you want to insert content, and then click on “+ Code” or “+ Text” to add Python code or text, respectively. Python Notebook is great for data science work, because: It encourages reproducible data analysis, when you run your analysis from start to finish. It encourages excellent documentation, as you can have code, output from code, and prose combined together. It is flexible to use other programming languages, such as R. Now, we will get to the basics of programming grammar. 1.5 Grammar Structure 1: Evaluation of Expressions Expressions are be built out of operations or functions. Functions and operations take in data types, do something with them, and return another data type. We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it. For instance, consider the following expressions entered to the Python Console: 18 + 21 ## 39 max(18, 21) ## 21 max(18 + 21, 65) ## 65 18 + (21 + 65) ## 104 len(&quot;ATCG&quot;) ## 4 Here, our input data types to the operation are integer in lines 1-4 and our input data type to the function is string in line 5. We will go over common data types shortly. Operations are just functions in hiding. We could have written: from operator import add add(18, 21) ## 39 add(18, add(21, 65)) ## 104 Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to readable code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Because the add() function isn’t typically used, it is not automatically available, so we used the import statement to load it in.) 1.5.1 Data types Here are some common data types we will be using in this course. Data type name Data type shorthand Examples Integer int 2, 4 Float float 3.5, -34.1009 String str “hello”, “234-234-8594” Boolean bool True, False A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class: Function machine from algebra class. Here are some aspects of this schema to pay attention to: A programmer should not need to know how the function is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language. A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the len() function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs. 1.6 Grammar Structure 2: Storing data types in the Variable Environment To build up a computer program, we need to store our returned data type from our expression somewhere for downstream use. We can assign a variable to it as follows: x = 18 + 21 If you enter this in the Console, you will see that in the Variable Environment, the variable x has a value of 39. 1.6.1 Execution rule for variable assignment Evaluate the expression to the right of =. Bind variable to the left of = to the resulting value. The variable is stored in the Variable Environment. The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined. The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. When we work with large datasets, if you assign a variable to a data type larger than the available RAM, it will not work. More on this later. Look, now x can be reused downstream: x - 2 ## 37 y = x * 2 It is quite common for programmers to not know what data type a variable is while they are coding. To learn about the data type of a variable, use the type() function on any variable in Python: type(y) ## &lt;class &#39;int&#39;&gt; We should give useful variable names so that we know what to expect! Consider num_sales instead of y. 1.7 Grammar Structure 3: Evaluation of Functions Let’s look at functions a little bit more formally: A function has a function name, arguments, and returns a data type. 1.7.1 Execution rule for functions: Evaluate the function by its arguments, and if the arguments are functions or contains operations, evaluate those functions or operations first. The output of functions is called the returned value. Often, we will use multiple functions, in a nested way, or use parenthesis to change the order of operation. Being able to read nested operations, nested functions, and parenthesis is very important. Think about what the Python is going to do step-by–step in the line of code below: (len(&quot;hello&quot;) + 4) * 2 ## 18 If we don’t know how to use a function, such as pow() we can ask for help: ?pow pow(base, exp, mod=None) Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments Some types, such as ints, are able to use a more efficient algorithm when invoked using the three argument form. This shows the function takes in three input arguments: base, exp, and mod=None. When an argument has an assigned value of mod=None, that means the input argument already has a value, and you don’t need to specify anything, unless you want to. The following ways are equivalent ways of using the pow() function: pow(2, 3) ## 8 pow(base=2, exp=3) ## 8 pow(exp=3, base=2) ## 8 but this will give you something different: pow(3, 2) ## 9 And there is an operational equivalent: 2 ** 3 ## 8 1.8 Tips on writing your first code Computer = powerful + stupid Even the smallest spelling and formatting changes will cause unexpected output and errors! Write incrementally, test often Check your assumptions, especially using new functions, operations, and new data types. Live environments are great for testing, but not great for reproducibility. Ask for help! To get more familiar with the errors Python gives you, take a look at this summary of Python error messages. "],["about-the-authors.html", "About the Authors", " About the Authors These credits are based on our course contributors table guidelines.     Credits Names Pedagogy Lead Content Instructor(s) FirstName LastName Lecturer(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved Delivered the course in some way - video or audio Content Author(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved If any other authors besides lead instructor Content Contributor(s) (include section name/link in parentheses) - make new line if more than one section involved Wrote less than a chapter Content Editor(s)/Reviewer(s) Checked your content Content Director(s) Helped guide the content direction Content Consultants (include chapter name/link in parentheses or word “General”) - make new line if more than one chapter involved Gave high level advice on content Acknowledgments Gave small assistance to content but not to the level of consulting Production Content Publisher(s) Helped with publishing platform Content Publishing Reviewer(s) Reviewed overall content and aesthetics on publishing platform Technical Course Publishing Engineer(s) Helped with the code for the technical aspects related to the specific course generation Template Publishing Engineers Candace Savonen, Carrie Wright, Ava Hoffman Publishing Maintenance Engineer Candace Savonen Technical Publishing Stylists Carrie Wright, Ava Hoffman, Candace Savonen Package Developers (ottrpal) Candace Savonen, John Muschelli, Carrie Wright Art and Design Illustrator(s) Created graphics for the course Figure Artist(s) Created figures/plots for course Videographer(s) Filmed videos Videography Editor(s) Edited film Audiographer(s) Recorded audio Audiography Editor(s) Edited audio recordings Funding Funder(s) Institution/individual who funded course including grant number Funding Staff Staff members who help with funding   ## ─ Session info ─────────────────────────────────────────────────────────────── ## setting value ## version R version 4.3.2 (2023-10-31) ## os Ubuntu 22.04.4 LTS ## system x86_64, linux-gnu ## ui X11 ## language (EN) ## collate en_US.UTF-8 ## ctype en_US.UTF-8 ## tz Etc/UTC ## date 2024-08-07 ## pandoc 3.1.1 @ /usr/local/bin/ (via rmarkdown) ## ## ─ Packages ─────────────────────────────────────────────────────────────────── ## package * version date (UTC) lib source ## bookdown 0.39.1 2024-06-11 [1] Github (rstudio/bookdown@f244cf1) ## bslib 0.6.1 2023-11-28 [1] RSPM (R 4.3.0) ## cachem 1.0.8 2023-05-01 [1] RSPM (R 4.3.0) ## cli 3.6.2 2023-12-11 [1] RSPM (R 4.3.0) ## devtools 2.4.5 2022-10-11 [1] RSPM (R 4.3.0) ## digest 0.6.34 2024-01-11 [1] RSPM (R 4.3.0) ## ellipsis 0.3.2 2021-04-29 [1] RSPM (R 4.3.0) ## evaluate 0.23 2023-11-01 [1] RSPM (R 4.3.0) ## fastmap 1.1.1 2023-02-24 [1] RSPM (R 4.3.0) ## fs 1.6.3 2023-07-20 [1] RSPM (R 4.3.0) ## glue 1.7.0 2024-01-09 [1] RSPM (R 4.3.0) ## htmltools 0.5.7 2023-11-03 [1] RSPM (R 4.3.0) ## htmlwidgets 1.6.4 2023-12-06 [1] RSPM (R 4.3.0) ## httpuv 1.6.14 2024-01-26 [1] RSPM (R 4.3.0) ## jquerylib 0.1.4 2021-04-26 [1] RSPM (R 4.3.0) ## jsonlite 1.8.8 2023-12-04 [1] RSPM (R 4.3.0) ## knitr 1.47.3 2024-06-11 [1] Github (yihui/knitr@e1edd34) ## later 1.3.2 2023-12-06 [1] RSPM (R 4.3.0) ## lifecycle 1.0.4 2023-11-07 [1] RSPM (R 4.3.0) ## magrittr 2.0.3 2022-03-30 [1] RSPM (R 4.3.0) ## memoise 2.0.1 2021-11-26 [1] RSPM (R 4.3.0) ## mime 0.12 2021-09-28 [1] RSPM (R 4.3.0) ## miniUI 0.1.1.1 2018-05-18 [1] RSPM (R 4.3.0) ## pkgbuild 1.4.3 2023-12-10 [1] RSPM (R 4.3.0) ## pkgload 1.3.4 2024-01-16 [1] RSPM (R 4.3.0) ## profvis 0.3.8 2023-05-02 [1] RSPM (R 4.3.0) ## promises 1.2.1 2023-08-10 [1] RSPM (R 4.3.0) ## purrr 1.0.2 2023-08-10 [1] RSPM (R 4.3.0) ## R6 2.5.1 2021-08-19 [1] RSPM (R 4.3.0) ## Rcpp 1.0.12 2024-01-09 [1] RSPM (R 4.3.0) ## remotes 2.4.2.1 2023-07-18 [1] RSPM (R 4.3.0) ## rlang 1.1.4 2024-06-04 [1] CRAN (R 4.3.2) ## rmarkdown 2.27.1 2024-06-11 [1] Github (rstudio/rmarkdown@e1c93a9) ## sass 0.4.8 2023-12-06 [1] RSPM (R 4.3.0) ## sessioninfo 1.2.2 2021-12-06 [1] RSPM (R 4.3.0) ## shiny 1.8.0 2023-11-17 [1] RSPM (R 4.3.0) ## stringi 1.8.3 2023-12-11 [1] RSPM (R 4.3.0) ## stringr 1.5.1 2023-11-14 [1] RSPM (R 4.3.0) ## urlchecker 1.0.1 2021-11-30 [1] RSPM (R 4.3.0) ## usethis 2.2.3 2024-02-19 [1] RSPM (R 4.3.0) ## vctrs 0.6.5 2023-12-01 [1] RSPM (R 4.3.0) ## xfun 0.44.4 2024-06-11 [1] Github (yihui/xfun@9da62cc) ## xtable 1.8-4 2019-04-21 [1] RSPM (R 4.3.0) ## yaml 2.3.8 2023-12-11 [1] RSPM (R 4.3.0) ## ## [1] /usr/local/lib/R/site-library ## [2] /usr/local/lib/R/library ## ## ────────────────────────────────────────────────────────────────────────────── "],["references.html", "Chapter 2 References", " Chapter 2 References "],["404.html", "Page not found", " Page not found The page you requested cannot be found (perhaps it was moved or renamed). You may want to try searching to find the page's new location, or use the table of contents to find the page you are looking for. "]]
+[["index.html", "Introduction to Python About this Course 0.1 Curriculum 0.2 Target Audience 0.3 Learning Objectives 0.4 Offerings", " Introduction to Python September, 2024 About this Course 0.1 Curriculum The course covers fundamentals of Python, a high-level programming language, and use it to wrangle data for analysis and visualization. 0.2 Target Audience The course is intended for researchers who want to learn coding for the first time with a data science application via the Python language. This course is also appropriate for folks who have explored data science or programming on their own and want to focus on some fundamentals. 0.3 Learning Objectives Analyze Tidy datasets in the Python programming language via data subsetting, joining, and transformations. Evaluate summary statistics and data visualization to understand scientific questions. Describe how the Python programming environment interpret complex expressions made out of functions, operations, and data structures, in a step-by-step way. Apply problem solving strategies to debug broken code. 0.4 Offerings This course is taught on a regular basis at Fred Hutch Cancer Center through the Data Science Lab. Announcements of course offering can be found here. "],["intro-to-computing.html", "Chapter 1 Intro to Computing 1.1 Goals of the course 1.2 What is a computer program? 1.3 A programming language has following elements: 1.4 Google Colab Setup 1.5 Grammar Structure 1: Evaluation of Expressions 1.6 Grammar Structure 2: Storing data types in the Variable Environment 1.7 Grammar Structure 3: Evaluation of Functions 1.8 Tips on writing your first code 1.9 Exercises", " Chapter 1 Intro to Computing Welcome to Introduction to Python! Each week, we cover a chapter, which consists of a lesson and exercise. In our first week together, we will look at big conceptual themes in programming, see how code is run, and learn some basic grammar structures of programming. 1.1 Goals of the course In the next 6 weeks, we will explore: Fundamental concepts in high-level programming languages (Python, R, Julia, etc.) that is transferable: How do programs run, and how do we solve problems using functions and data structures? Beginning of data science fundamentals: How do you translate your scientific question to a data wrangling problem and answer it? Data science workflow. Image source: R for Data Science. Find a nice balance between the two throughout the course: we will try to reproduce a figure from a scientific publication using new data. 1.2 What is a computer program? A sequence of instructions to manipulate data for the computer to execute. A series of translations: English &lt;-&gt; Programming Code for Interpreter &lt;-&gt; Machine Code for Central Processing Unit (CPU) We will focus on English &lt;-&gt; Programming Code for Python Interpreter in this class. More importantly: How we organize ideas &lt;-&gt; Instructing a computer to do something. 1.3 A programming language has following elements: Grammar structure to construct expressions; combining expressions to create more complex expressions Encapsulate complex expressions via functions to create modular and reusable tasks Encapsulate complex data via data structures to allow efficient manipulation of data 1.4 Google Colab Setup Google Colab is a Integrated Development Environment (IDE) on a web browser. Think about it as Microsoft Word to a plain text editor. It provides extra bells and whistles to using Python that is easier for the user. Let’s open up the KRAS analysis in Google Colab. If you are taking this course while it is in session, the project name is probably named “KRAS Demo” in your Google Classroom workspace. If you are taking this course on your own time, you can view it here. Today, we will pay close attention to: Python Console (“Executions”): Open it via View -&gt; Executed code history. You give it one line of Python code, and the console executes that single line of code; you give it a single piece of instruction, and it executes it for you. Notebook: in the central panel of the website, you will see Python code interspersed with word document text. This is called a Python Notebook (other similar services include Jupyter Notebook, iPython Notebook), which has chunks of plain text and Python code, and it helps us understand better the code we are writing. Variable Environment: Open it by clicking on the “{x}” button on the left-hand panel. Often, your code will store information in the Variable Environment, so that information can be reused. For instance, we often load in data and store it in the Variable Environment, and use it throughout rest of your Python code. The first thing we will do is see the different ways we can run Python code. You can do the following: Type something into the Python Console (Execution) and click the arrow button, such as 2+2. The Python Console will run it and give you an output. Look through the Python Notebook, and when you see a chunk of Python Code, click the arrow button. It will copy the Python code chunk to the Python Console and run all of it. You will likely see variables created in the Variables panel as you load in and manipulate data. Run every single Python code chunk via Runtime -&gt; Run all. Remember that the order that you run your code matters in programming. Your final product would be the result of Option 3, in which you run every Python code chunk from start to finish. However, sometimes it is nice to try out smaller parts of your code via Options 1 or 2. But you will be at risk of running your code out of order! To create your own content in the notebook, click on a section you want to insert content, and then click on “+ Code” or “+ Text” to add Python code or text, respectively. Python Notebook is great for data science work, because: It encourages reproducible data analysis, when you run your analysis from start to finish. It encourages excellent documentation, as you can have code, output from code, and prose combined together. It is flexible to use other programming languages, such as R. The version of Python used in this course and in Google Colab is Python 3, which is the version of Python that is most supported. Some Python software is written in Python 2, which is very similar but has some notable differences. Now, we will get to the basics of programming grammar. 1.5 Grammar Structure 1: Evaluation of Expressions Expressions are be built out of operations or functions. Functions and operations take in data types as inputs, do something with them, and return another data type as ouput. We can combine multiple expressions together to form more complex expressions: an expression can have other expressions nested inside it. For instance, consider the following expressions entered to the Python Console: 18 + 21 ## 39 max(18, 21) ## 21 max(18 + 21, 65) ## 65 18 + (21 + 65) ## 104 len(&quot;ATCG&quot;) ## 4 Here, our input data types to the operation are integer in lines 1-4 and our input data type to the function is string in line 5. We will go over common data types shortly. Operations are just functions in hiding. We could have written: from operator import add add(18, 21) ## 39 add(18, add(21, 65)) ## 104 Remember that the Python language is supposed to help us understand what we are writing in code easily, lending to readable code. Therefore, it is sometimes useful to come up with operations that is easier to read. (Most functions in Python are stored in a collection of functions called modules that needs to be loaded. The import statement gives us permission to access the functions in the module “operator”.) 1.5.1 Function machine schema A nice way to summarize this first grammar structure is using the function machine schema, way back from algebra class: Function machine from algebra class. Here are some aspects of this schema to pay attention to: A programmer should not need to know how the function or operation is implemented in order to use it - this emphasizes abstraction and modular thinking, a foundation in any programming language. A function can have different kinds of inputs and outputs - it doesn’t need to be numbers. In the len() function, the input is a String, and the output is an Integer. We will see increasingly complex functions with all sorts of different inputs and outputs. 1.5.2 Data types Here are some common data types we will be using in this course. Data type name Data type shorthand Examples Integer int 2, 4 Float float 3.5, -34.1009 String str “hello”, “234-234-8594” Boolean bool True, False 1.6 Grammar Structure 2: Storing data types in the Variable Environment To build up a computer program, we need to store our returned data type from our expression somewhere for downstream use. We can assign a variable to it as follows: x = 18 + 21 If you enter this in the Console, you will see that in the Variable Environment, the variable x has a value of 39. 1.6.1 Execution rule for variable assignment Evaluate the expression to the right of =. Bind variable to the left of = to the resulting value. The variable is stored in the Variable Environment. The Variable Environment is where all the variables are stored, and can be used for an expression anytime once it is defined. Only one unique variable name can be defined. The variable is stored in the working memory of your computer, Random Access Memory (RAM). This is temporary memory storage on the computer that can be accessed quickly. Typically a personal computer has 8, 16, 32 Gigabytes of RAM. Look, now x can be reused downstream: x - 2 ## 37 y = x * 2 It is quite common for programmers to have to look up the data type of a variable while they are coding. To learn about the data type of a variable, use the type() function on any variable in Python: type(y) ## &lt;class &#39;int&#39;&gt; We should give useful variable names so that we know what to expect! If you are working with numerical sales data, consider num_sales instead of y. 1.7 Grammar Structure 3: Evaluation of Functions Let’s look at functions a little bit more formally: A function has a function name, arguments, and returns a data type. 1.7.1 Execution rule for functions: Evaluate the function by its arguments if there’s any, and if the arguments are functions or contains operations, evaluate those functions or operations first. The output of functions is called the returned value. Often, we will use multiple functions in a nested way, and it is important to understand how the Python console understand the order of operation. We can also use parenthesis to change the order of operation. Think about what the Python is going to do step-by–step in the lines of code below: max(len(&quot;hello&quot;), 4) ## 5 (len(&quot;pumpkin&quot;) - 8) * 2 ## -2 If we don’t know how to use a function, such as pow(), we can ask for help: ?pow pow(base, exp, mod=None) Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments Some types, such as ints, are able to use a more efficient algorithm when invoked using the three argument form. We can also find a similar help document, in a nicer rendered form online. We will practice looking at function documentation throughout the course, because that is a fundamental skill to learn more functions on your own. The documentation shows the function takes in three input arguments: base, exp, and mod=None. When an argument has an assigned value of mod=None, that means the input argument already has a value, and you don’t need to specify anything, unless you want to. The following ways are equivalent ways of using the pow() function: pow(2, 3) ## 8 pow(base=2, exp=3) ## 8 pow(exp=3, base=2) ## 8 but this will give you something different: pow(3, 2) ## 9 And there is an operational equivalent: 2 ** 3 ## 8 We will mostly look at functions with input arguments and return types in this course, but not all functions need to have input arguments and output return. Let’s look at some examples of functions that don’t always have an input or output: Function call What it takes in What it does Returns pow(a, b) integer a, integer b Raises a to the bth power. Integer time.sleep(x) Integer x Waits for x seconds. None dir() Nothing Gives a list of all the variables defined in the environment. List 1.8 Tips on writing your first code Computer = powerful + stupid Computers are excellent at doing something specific over and over again, but is extremely rigid and lack flexibility. Here are some tips that is helpful for beginners: Write incrementally, test often. Don’t be afraid to break things: it is how we learn how things work in programming. Check your assumptions, especially using new functions, operations, and new data types. Live environments are great for testing, but not great for reproducibility. Ask for help! To get more familiar with the errors Python gives you, take a look at this summary of Python error messages. 1.9 Exercises Exercise for week 1 can be found here. "],["working-with-data-structures.html", "Chapter 2 Working with data structures 2.1 Lists 2.2 Objects in Python 2.3 Methods vs Functions 2.4 Dataframes 2.5 What does a Dataframe contain? 2.6 What can a Dataframe do? 2.7 Subsetting Dataframes 2.8 Exercises", " Chapter 2 Working with data structures In our second lesson, we start to look at two data structures, Lists and Dataframes, that can handle a large amount of data for analysis. 2.1 Lists In the first exercise, you started to explore data structures, which store information about data types. You explored lists, which is an ordered collection of data types or data structures. Each element of a list contains a data type or another data structure. We can now store a vast amount of information in a list, and assign it to a single variable. Even more, we can use operations and functions on a list, modifying many elements within the list at once! This makes analyzing data much more scalable and less repetitive. We create a list via the bracket [ ] operation. staff = [&quot;chris&quot;, &quot;ted&quot;, &quot;jeff&quot;] chrNum = [2, 3, 1, 2, 2] mixedList = [False, False, False, &quot;A&quot;, &quot;B&quot;, 92] 2.1.1 Subsetting lists To access an element of a list, you can use the bracket notation [ ] to access the elements of the list. We simply access an element via the “index” number - the location of the data within the list. Here’s the tricky thing about the index number: it starts at 0! 1st element of chrNum: chrNum[0] 2nd element of chrNum: chrNum[1] … 5th element of chrNum: chrNum[4] With subsetting, you can modify elements of a list or use the element of a list as part of an expression. 2.1.2 Subsetting multiple elements of lists Suppose you want to access multiple elements of a list, such as accessing the first three elements of chrNum. You would use the slice operator :, which specifies: the index number to start the index number to stop, plus one. If you want to access the first three elements of chrNum: chrNum[0:3] ## [2, 3, 1] The first element’s index number is 0, the third element’s index number is 2, plus 1, which is 3. If you want to access the second and third elements of chrNum: chrNum[1:3] ## [3, 1] Another way of accessing the first 3 elements of chrNum: chrNum[:3] ## [2, 3, 1] Here, the start index number was not specified. When the start or stop index is not specified, it implies that you are subsetting starting the from the beginning of the list or subsetting to the end of the list, respectively. Here’s another example, using negative indicies to count from 3 elements from the end of the list: chrNum[-3:] ## [1, 2, 2] You can find more discussion of list slicing, using negative indicies and incremental slicing, here. 2.2 Objects in Python The list data structure has an organization and functionality that metaphorically represents a pen-and-paper list in our physical world. Like a physical object, we have examined: What does it contain (in terms of data)? What can it do (in terms of functions)? And if it “makes sense” to us, then it is well-designed. The list data structure we have been working with is an example of an Object. The definition of an object allows us to ask the questions above: what does it contain, and what can it do? It is an organizational tool for a collection of data and functions that we can relate to, like a physical object. Formally, an object contains the following: Value that holds the essential data for the object. Attributes that hold subset or additional data for the object. Functions called Methods that are for the object and have to take in the variable referenced as an input This organizing structure on an object applies to pretty much all Python data types and data structures. Let’s see how this applies to the list: Value: the contents of the list, such as [2, 3, 4]. Attributes that store additional values: Not relevant for lists. Methods that can be used on the object: chrNum.count(2) counts the number of instances 2 appears as an element of chrNum. Object methods are functions that does something with the object you are using it on. You should think about chrNum.count(2) as a function that takes in chrNum and 2 as inputs. If you want to use the count function on list mixedList, you would use mixedList.count(x). Here are some more examples of methods with lists: Function method What it takes in What it does Returns chrNum.count(x) list chrNum, data type x Counts the number of instances x appears as an element of chrNum. Integer chrNum.append(x) list chrNum, data type x Appends x to the end of the chrNum. None (but chrNum is modified!) chrNum.sort() list chrNum Sorts chrNum by ascending order. None (but chrNum is modified!) chrNum.reverse() list chrNum Reverses the order of chrNum. None (but chrNum is modified!) 2.3 Methods vs Functions Methods have to take in the object of interest as an input: chrNum.count(2) automatically treat chrNum as an input. Methods are built for a specific Object type. Functions do not have an implied input: len(chrNum) requires specifying a list in the input. Otherwise, there is no strong distinction between the two. 2.4 Dataframes A Dataframe is a two-dimensional data structure that stores data like a spreadsheet does. The Dataframe data structure is found within a Python module called “Pandas”. A Python module is an organized collection of functions and data structures. The import statement below gives us permission to access the “Pandas” module via the variable pd. To load in a Dataframe from existing spreadsheet data, we use the function pd.read_csv(): import pandas as pd metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) type(metadata) ## &lt;class &#39;pandas.core.frame.DataFrame&#39;&gt; There is a similar function pd.read_excel() for loading in Excel spreadsheets. Let’s investigate the Dataframe as an object: What does a Dataframe contain (values, attributes)? What can a Dataframe do (methods)? 2.5 What does a Dataframe contain? We first take a look at the contents: metadata ## ModelID ... OncotreeLineage ## 0 ACH-000001 ... Ovary/Fallopian Tube ## 1 ACH-000002 ... Myeloid ## 2 ACH-000003 ... Bowel ## 3 ACH-000004 ... Myeloid ## 4 ACH-000005 ... Myeloid ## ... ... ... ... ## 1859 ACH-002968 ... Esophagus/Stomach ## 1860 ACH-002972 ... Esophagus/Stomach ## 1861 ACH-002979 ... Esophagus/Stomach ## 1862 ACH-002981 ... Esophagus/Stomach ## 1863 ACH-003071 ... Lung ## ## [1864 rows x 30 columns] It looks like there are 1864 rows and 30 columns in this Dataframe, and when we display it it shows some of the data. metadata ## ModelID ... OncotreeLineage ## 0 ACH-000001 ... Ovary/Fallopian Tube ## 1 ACH-000002 ... Myeloid ## 2 ACH-000003 ... Bowel ## 3 ACH-000004 ... Myeloid ## 4 ACH-000005 ... Myeloid ## ... ... ... ... ## 1859 ACH-002968 ... Esophagus/Stomach ## 1860 ACH-002972 ... Esophagus/Stomach ## 1861 ACH-002979 ... Esophagus/Stomach ## 1862 ACH-002981 ... Esophagus/Stomach ## 1863 ACH-003071 ... Lung ## ## [1864 rows x 30 columns] We can look at specific columns by looking at attributes via the dot operation. We can also look at the columns via the bracket operation. metadata.ModelID ## 0 ACH-000001 ## 1 ACH-000002 ## 2 ACH-000003 ## 3 ACH-000004 ## 4 ACH-000005 ## ... ## 1859 ACH-002968 ## 1860 ACH-002972 ## 1861 ACH-002979 ## 1862 ACH-002981 ## 1863 ACH-003071 ## Name: ModelID, Length: 1864, dtype: object metadata[&#39;ModelID&#39;] ## 0 ACH-000001 ## 1 ACH-000002 ## 2 ACH-000003 ## 3 ACH-000004 ## 4 ACH-000005 ## ... ## 1859 ACH-002968 ## 1860 ACH-002972 ## 1861 ACH-002979 ## 1862 ACH-002981 ## 1863 ACH-003071 ## Name: ModelID, Length: 1864, dtype: object The names of all columns is stored as an attribute, which can be accessed via the dot operation. metadata.columns ## Index([&#39;ModelID&#39;, &#39;PatientID&#39;, &#39;CellLineName&#39;, &#39;StrippedCellLineName&#39;, &#39;Age&#39;, ## &#39;SourceType&#39;, &#39;SangerModelID&#39;, &#39;RRID&#39;, &#39;DepmapModelType&#39;, &#39;AgeCategory&#39;, ## &#39;GrowthPattern&#39;, &#39;LegacyMolecularSubtype&#39;, &#39;PrimaryOrMetastasis&#39;, ## &#39;SampleCollectionSite&#39;, &#39;Sex&#39;, &#39;SourceDetail&#39;, &#39;LegacySubSubtype&#39;, ## &#39;CatalogNumber&#39;, &#39;CCLEName&#39;, &#39;COSMICID&#39;, &#39;PublicComments&#39;, ## &#39;WTSIMasterCellID&#39;, &#39;EngineeredModel&#39;, &#39;TreatmentStatus&#39;, ## &#39;OnboardedMedia&#39;, &#39;PlateCoating&#39;, &#39;OncotreeCode&#39;, &#39;OncotreeSubtype&#39;, ## &#39;OncotreePrimaryDisease&#39;, &#39;OncotreeLineage&#39;], ## dtype=&#39;object&#39;) The number of rows and columns are also stored as an attribute: metadata.shape ## (1864, 30) 2.6 What can a Dataframe do? We can use the .head() and .tail() methods to look at the first few rows and last few rows of metadata, respectively: metadata.head() ## ModelID PatientID ... OncotreePrimaryDisease OncotreeLineage ## 0 ACH-000001 PT-gj46wT ... Ovarian Epithelial Tumor Ovary/Fallopian Tube ## 1 ACH-000002 PT-5qa3uk ... Acute Myeloid Leukemia Myeloid ## 2 ACH-000003 PT-puKIyc ... Colorectal Adenocarcinoma Bowel ## 3 ACH-000004 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## 4 ACH-000005 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## ## [5 rows x 30 columns] metadata.tail() ## ModelID PatientID ... OncotreePrimaryDisease OncotreeLineage ## 1859 ACH-002968 PT-pjhrsc ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1860 ACH-002972 PT-dkXZB1 ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1861 ACH-002979 PT-lyHTzo ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1862 ACH-002981 PT-Z9akXf ... Esophagogastric Adenocarcinoma Esophagus/Stomach ## 1863 ACH-003071 PT-LAGmLq ... Lung Neuroendocrine Tumor Lung ## ## [5 rows x 30 columns] Both of these functions (without input arguments) are considered as methods: they are functions that does something with the Dataframe you are using it on. You should think about metadata.head() as a function that takes in metadata as an input. If we had another Dataframe called my_data and you want to use the same function, you will have to say my_data.head(). 2.7 Subsetting Dataframes Perhaps the most important operation you will can do with Dataframes is subsetting them. There are two ways to do it. The first way is to subset by numerical indicies, exactly like how we did for lists. You will use the iloc attribute and bracket operations, and you give two slices: one for the row, and one for the column. Let’s start with a small dataframe to see how it works before returning to metadata: df = pd.DataFrame(data={&#39;status&#39;: [&quot;treated&quot;, &quot;untreated&quot;, &quot;untreated&quot;, &quot;discharged&quot;, &quot;treated&quot;], &#39;age_case&#39;: [25, 43, 21, 65, 7], &#39;age_control&#39;: [49, 20, 32, 25, 32]}) df ## status age_case age_control ## 0 treated 25 49 ## 1 untreated 43 20 ## 2 untreated 21 32 ## 3 discharged 65 25 ## 4 treated 7 32 Here is how the dataframe looks like with the row and column index numbers: Subset the first fourth rows, and the first two columns: Now, back to metadata dataframe: Subset the first 5 rows, and first two columns: metadata.iloc[:5, :2] ## ModelID PatientID ## 0 ACH-000001 PT-gj46wT ## 1 ACH-000002 PT-5qa3uk ## 2 ACH-000003 PT-puKIyc ## 3 ACH-000004 PT-q4K2cp ## 4 ACH-000005 PT-q4K2cp If we want a custom slice that is not sequential, we can use an integer list. Subset the last 5 rows, and the 1st and 10 and 21th column: metadata.iloc[5:, [1, 10, 21]] ## PatientID GrowthPattern WTSIMasterCellID ## 5 PT-ej13Dz Suspension 2167.0 ## 6 PT-NOXwpH Adherent 569.0 ## 7 PT-fp8PeY Adherent 1806.0 ## 8 PT-puKIyc Adherent 2104.0 ## 9 PT-AR7W9o Adherent NaN ## ... ... ... ... ## 1859 PT-pjhrsc Organoid NaN ## 1860 PT-dkXZB1 Organoid NaN ## 1861 PT-lyHTzo Organoid NaN ## 1862 PT-Z9akXf Organoid NaN ## 1863 PT-LAGmLq Suspension NaN ## ## [1859 rows x 3 columns] When we subset via numerical indicies, it’s called explicit subsetting. This is a great way to start thinking about subsetting your dataframes for analysis, but explicit subsetting can lead to some inconsistencies in the long run. For instance, suppose your collaborator added a new cell line to the metadata and changed the order of the column. Then your code to subset the last 5 rows and the columns will get you a different answer once the spreadsheet is changed. The second way is to subset by the column name and comparison operators, also known as implicit subsetting. This is much more robust in data analysis practice. You will learn about it next week! 2.8 Exercises Exercise for week 2 can be found here. "],["data-wrangling-part-1.html", "Chapter 3 Data Wrangling, Part 1 3.1 Tidy Data 3.2 Our working Tidy Data: DepMap Project 3.3 Transform: “What do you want to do with this Dataframe”? 3.4 Summary Statistics 3.5 Simple data visualization 3.6 Exercises", " Chapter 3 Data Wrangling, Part 1 From our first two lessons, we are now equipped with enough fundamental programming skills to apply it to various steps in the data science workflow, which is a natural cycle that occurs in data analysis. Data science workflow. Image source: R for Data Science. For the rest of the course, we focus on Transform and Visualize with the assumption that our data is in a nice, “Tidy format”. First, we need to understand what it means for a data to be “Tidy”. 3.1 Tidy Data Here, we describe a standard of organizing data. It is important to have standards, as it facilitates a consistent way of thinking about data organization and building tools (functions) that make use of that standard. The principles of tidy data, developed by Hadley Wickham: Each variable must have its own column. Each observation must have its own row. Each value must have its own cell. If you want to be technical about what variables and observations are, Hadley Wickham describes: A variable contains all values that measure the same underlying attribute (like height, temperature, duration) across units. An observation contains all values measured on the same unit (like a person, or a day, or a race) across attributes. A tidy dataframe. Image source: R for Data Science. 3.2 Our working Tidy Data: DepMap Project The Dependency Map project is a multi-omics profiling of cancer cell lines combined with functional assays such as CRISPR and drug sensitivity to help identify cancer vulnerabilities and drug targets. Here are some of the data that we have public access to. We have been looking at the metadata since last session. Metadata Somatic mutations Gene expression Drug sensitivity CRISPR knockout and more… Let’s load these datasets in, and see how these datasets fit the definition of Tidy data: import pandas as pd metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) mutation = pd.read_csv(&quot;classroom_data/mutation.csv&quot;) expression = pd.read_csv(&quot;classroom_data/expression.csv&quot;) metadata.head() ## ModelID PatientID ... OncotreePrimaryDisease OncotreeLineage ## 0 ACH-000001 PT-gj46wT ... Ovarian Epithelial Tumor Ovary/Fallopian Tube ## 1 ACH-000002 PT-5qa3uk ... Acute Myeloid Leukemia Myeloid ## 2 ACH-000003 PT-puKIyc ... Colorectal Adenocarcinoma Bowel ## 3 ACH-000004 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## 4 ACH-000005 PT-q4K2cp ... Acute Myeloid Leukemia Myeloid ## ## [5 rows x 30 columns] mutation.head() ## ModelID CACNA1D_Mut CYP2D6_Mut ... CCDC28A_Mut C1orf194_Mut U2AF1_Mut ## 0 ACH-000001 False False ... False False False ## 1 ACH-000002 False False ... False False False ## 2 ACH-000004 False False ... False False False ## 3 ACH-000005 False False ... False False False ## 4 ACH-000006 False False ... False False False ## ## [5 rows x 540 columns] expression.head() ## ModelID ENPP4_Exp CREBBP_Exp ... OR5D13_Exp C2orf81_Exp OR8S1_Exp ## 0 ACH-001113 2.280956 4.094236 ... 0.0 1.726831 0.0 ## 1 ACH-001289 3.622930 3.606442 ... 0.0 0.790772 0.0 ## 2 ACH-001339 0.790772 2.970854 ... 0.0 0.575312 0.0 ## 3 ACH-001538 3.485427 2.801159 ... 0.0 1.077243 0.0 ## 4 ACH-000242 0.879706 3.327687 ... 0.0 0.722466 0.0 ## ## [5 rows x 536 columns] Dataframe The observation is Some variables are Some values are metadata Cell line ModelID, Age, OncotreeLineage “ACH-000001”, 60, “Myeloid” expression Cell line KRAS_Exp 2.4, .3 mutation Cell line KRAS_Mut TRUE, FALSE 3.3 Transform: “What do you want to do with this Dataframe”? Remember that a major theme of the course is about: How we organize ideas &lt;-&gt; Instructing a computer to do something. Until now, we haven’t focused too much on how we organize our scientific ideas to interact with what we can do with code. Let’s pivot to write our code driven by our scientific curiosity. After we are sure that we are working with Tidy data, we can ponder how we want to transform our data that satisfies our scientific question. We will look at several ways we can transform Tidy data, starting with subsetting columns and rows. Here’s a starting prompt: In the metadata dataframe, which rows would you subset for and columns would you subset for that relate to a scientific question? We have been using explicit subsetting with numerical indicies, such as “I want to filter for rows 20-50 and select columns 2 and 8”. We are now going to switch to implicit subsetting in which we describe the subsetting criteria via comparision operators and column names, such as: “I want to subset for rows such that the OncotreeLineage is breast cancer and subset for columns Age and Sex.” Notice that when we subset for rows in an implicit way, we formulate our criteria in terms of the columns.This is because we are guaranteed to have column names in Dataframes, but not row names. 3.3.0.1 Let’s convert our implicit subsetting criteria into code! To subset for rows implicitly, we will use the conditional operators on Dataframe columns you used in Exercise 2. To formulate a conditional operator expression that OncotreeLineage is breast cancer: metadata[&#39;OncotreeLineage&#39;] == &quot;Lung&quot; ## 0 False ## 1 False ## 2 False ## 3 False ## 4 False ## ... ## 1859 False ## 1860 False ## 1861 False ## 1862 False ## 1863 True ## Name: OncotreeLineage, Length: 1864, dtype: bool Then, we will use the .loc operation (which is different than .iloc operation!) and subsetting brackets to subset rows and columns Age and Sex at the same time: metadata.loc[metadata[&#39;OncotreeLineage&#39;] == &quot;Lung&quot;, [&quot;Age&quot;, &quot;Sex&quot;]] ## Age Sex ## 10 39.0 Female ## 13 44.0 Male ## 19 55.0 Female ## 27 39.0 Female ## 28 45.0 Male ## ... ... ... ## 1745 52.0 Male ## 1819 84.0 Male ## 1820 57.0 Female ## 1822 53.0 Male ## 1863 62.0 Male ## ## [241 rows x 2 columns] What’s going on here? The first component of the subset, metadata['OncotreeLineage'] == \"Lung\", subsets for the rows. It gives us a column of True and False values, and we keep rows that correspond to True values. Then, we specify the column names we want to subset for via a list. Here’s another example: df = pd.DataFrame(data={&#39;status&#39;: [&quot;treated&quot;, &quot;untreated&quot;, &quot;untreated&quot;, &quot;discharged&quot;, &quot;treated&quot;], &#39;age_case&#39;: [25, 43, 21, 65, 7], &#39;age_control&#39;: [49, 20, 32, 25, 32]}) df ## status age_case age_control ## 0 treated 25 49 ## 1 untreated 43 20 ## 2 untreated 21 32 ## 3 discharged 65 25 ## 4 treated 7 32 “I want to subset for rows such that the status is”treated” and subset for columns status and age_case.” df.loc[df.status == &quot;treated&quot;, [&quot;status&quot;, &quot;age_case&quot;]] ## status age_case ## 0 treated 25 ## 4 treated 7 3.4 Summary Statistics Now that your Dataframe has be transformed based on your scientific question, you can start doing some analysis on it! A common data science task is to examine summary statistics of a dataset, which summarizes the all the values from a variable in a numeric summary, such as mean, median, or mode. If we look at the data structure of a Dataframe’s column, it is actually not a List, but an object called Series. It has methods can compute summary statistics for us. Let’s take a look at a few popular examples: Function method What it takes in What it does Returns metadata.Age.mean() metadata.Age as a numeric Series Computes the mean value of the Age column. Float (NumPy) metadata['Age'].median() metadata['Age'] as a numeric Series Computes the median value of the Age column. Float (NumPy) metadata.Age.max() metadata.Age as a numeric Series Computes the max value of the Age column. Float (NumPy) metadata.OncotreeSubtype.value_counts() metadata.OncotreeSubtype as a string Series Creates a frequency table of all unique elements in OncotreeSubtype column. Series Let’s try it out, with some nice print formatting: print(&quot;Mean value of Age column:&quot;, metadata[&#39;Age&#39;].mean()) ## Mean value of Age column: 47.45187165775401 print(&quot;Frequency of column&quot;, metadata.OncotreeLineage.value_counts()) ## Frequency of column OncotreeLineage ## Lung 241 ## Lymphoid 209 ## CNS/Brain 123 ## Skin 118 ## Esophagus/Stomach 95 ## Breast 92 ## Bowel 87 ## Head and Neck 81 ## Myeloid 77 ## Bone 75 ## Ovary/Fallopian Tube 74 ## Pancreas 65 ## Kidney 64 ## Peripheral Nervous System 55 ## Soft Tissue 54 ## Uterus 41 ## Fibroblast 41 ## Biliary Tract 40 ## Bladder/Urinary Tract 39 ## Normal 39 ## Pleura 35 ## Liver 28 ## Cervix 25 ## Eye 19 ## Thyroid 18 ## Prostate 14 ## Vulva/Vagina 5 ## Ampulla of Vater 4 ## Testis 4 ## Adrenal Gland 1 ## Other 1 ## Name: count, dtype: int64 Notice that the output of some of these methods are Float (NumPy). This refers to a Python Object called NumPy that is extremely popular for scientific computing, but we’re not focused on that in this course.) 3.5 Simple data visualization We will dedicate extensive time later this course to talk about data visualization, but the Dataframe’s column, Series, has a method called .plot() that can help us make simple plots for one variable. The .plot() method will by default make a line plot, but it is not necessary the plot style we want, so we can give the optional argument kind a String value to specify the plot style. We use it for making a histogram or bar plot. Plot style Useful for kind = Code Histogram Numerics “hist” metadata.Age.plot(kind = \"hist\") Bar plot Strings “bar” metadata.OncotreeSubtype.value_counts().plot(kind = \"bar\") Let’s look at a histogram: import matplotlib.pyplot as plt plt.figure() metadata.Age.plot(kind = &quot;hist&quot;) plt.show() Let’s look at a bar plot: plt.figure() metadata.OncotreeLineage.value_counts().plot(kind = &quot;bar&quot;) plt.show() (The plt.figure() and plt.show() functions are used to render the plots on the website, but you don’t need to use it for your exercises. We will discuss this in more detail during our week of data visualization.) 3.5.0.1 Chained function calls Let’s look at our bar plot syntax more carefully. We start with the column metadata.OncotreeLineage, and then we first use the method .value_counts() to get a Series of a frequency table. Then, we take the frequency table Series and use the .plot() method. It is quite common in Python to have multiple “chained” function calls, in which the output of .value_counts() is used for the input of .plot() all in one line of code. It takes a bit of time to get used to this! Here’s another example of a chained function call, which looks quite complex, but let’s break it down: plt.figure() metadata.loc[metadata.AgeCategory == &quot;Adult&quot;, ].OncotreeLineage.value_counts().plot(kind=&quot;bar&quot;) plt.show() We first take the entire metadata and do some subsetting, which outputs a Dataframe. We access the OncotreeLineage column, which outputs a Series. We use the method .value_counts(), which outputs a Series. We make a plot out of it! We could have, alternatively, done this in several lines of code: plt.figure() metadata_subset = metadata.loc[metadata.AgeCategory == &quot;Adult&quot;, ] metadata_subset_lineage = metadata_subset.OncotreeLineage lineage_freq = metadata_subset_lineage.value_counts() lineage_freq.plot(kind = &quot;bar&quot;) plt.show() These are two different styles of code, but they do the exact same thing. It’s up to you to decide what is easier for you to understand. 3.6 Exercises Exercise for week 3 can be found here. "],["data-wrangling-part-2.html", "Chapter 4 Data Wrangling, Part 2 4.1 Creating new columns 4.2 Merging two Dataframes together 4.3 Grouping and summarizing Dataframes 4.4 Exercises", " Chapter 4 Data Wrangling, Part 2 We will continue to learn about data analysis with Dataframes. Let’s load our three Dataframes from the Depmap project in again: import pandas as pd import numpy as np metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) mutation = pd.read_csv(&quot;classroom_data/mutation.csv&quot;) expression = pd.read_csv(&quot;classroom_data/expression.csv&quot;) 4.1 Creating new columns Often, we want to perform some kind of transformation on our data’s columns: perhaps you want to add the values of columns together, or perhaps you want to represent your column in a different scale. To create a new column, you simply modify it as if it exists using the bracket operation [ ], and the column will be created: metadata[&#39;AgePlusTen&#39;] = metadata[&#39;Age&#39;] + 10 expression[&#39;KRAS_NRAS_exp&#39;] = expression[&#39;KRAS_Exp&#39;] + expression[&#39;NRAS_Exp&#39;] expression[&#39;log_PIK3CA_Exp&#39;] = np.log(expression[&#39;PIK3CA_Exp&#39;]) where np.log(x) is a function imported from the module NumPy that takes in a numeric and returns the log-transformed value. Note: you cannot create a new column referring to the attribute of the Dataframe, such as: expression.KRAS_Exp_log = np.log(expression.KRAS_Exp). 4.2 Merging two Dataframes together Suppose we have the following Dataframes: expression ModelID PIK3CA_Exp log_PIK3CA_Exp “ACH-001113” 5.138733 1.636806 “ACH-001289” 3.184280 1.158226 “ACH-001339” 3.165108 1.152187 metadata ModelID OncotreeLineage Age “ACH-001113” “Lung” 69 “ACH-001289” “CNS/Brain” NaN “ACH-001339” “Skin” 14 Suppose that I want to compare the relationship between OncotreeLineage and PIK3CA_Exp, but they are columns in different Dataframes. We want a new Dataframe that looks like this: ModelID PIK3CA_Exp log_PIK3CA_Exp OncotreeLineage Age “ACH-001113” 5.138733 1.636806 “Lung” 69 “ACH-001289” 3.184280 1.158226 “CNS/Brain” NaN “ACH-001339” 3.165108 1.152187 “Skin” 14 We see that in both dataframes, the rows (observations) represent cell lines. there is a common column ModelID, with shared values between the two dataframes that can faciltate the merging process. We call this an index. We will use the method .merge() for Dataframes. It takes a Dataframe to merge with as the required input argument. The method looks for a common index column between the two dataframes and merge based on that index. merged = metadata.merge(expression) It’s usually better to specify what that index column to avoid ambiguity, using the on optional argument: merged = metadata.merge(expression, on=&#39;ModelID&#39;) If the index column for the two Dataframes are named differently, you can specify the column name for each Dataframe: merged = metadata.merge(expression, left_on=&#39;ModelID&#39;, right_on=&#39;ModelID&#39;) One of the most import checks you should do when merging dataframes is to look at the number of rows and columns before and after merging to see whether it makes sense or not: The number of rows and columns of metadata: metadata.shape ## (1864, 31) The number of rows and columns of expression: expression.shape ## (1450, 538) The number of rows and columns of merged: merged.shape ## (1450, 568) We see that the number of columns in merged combines the number of columns in metadata and expression, while the number of rows in merged is the smaller of the number of rows in metadata and expression: it only keeps rows that are found in both Dataframe’s index columns. This kind of join is called “inner join”, because in the Venn Diagram of elements common in both index column, we keep the inner overlap: You can specifiy the join style by changing the optional input argument how. how = \"outer\" keeps all observations - also known as a “full join” how = \"left\" keeps all observations in the left Dataframe. how = \"right\" keeps all observations in the right Dataframe. how = \"inner\" keeps observations common to both Dataframe. This is the default value of how. 4.3 Grouping and summarizing Dataframes In a dataset, there may be groups of observations that we want to understand, such as case vs. control, or comparing different cancer subtypes. For example, in metadata, the observation is cell lines, and perhaps we want to group cell lines into their respective cancer type, OncotreeLineage, and look at the mean age for each cancer type. We want to take metadata: ModelID OncotreeLineage Age “ACH-001113” “Lung” 69 “ACH-001289” “Lung” 23 “ACH-001339” “Skin” 14 “ACH-002342” “Brain” 23 “ACH-004854” “Brain” 56 “ACH-002921” “Brain” 67 into: OncotreeLineage MeanAge “Lung” 46 “Skin” 14 “Brain” 48.67 To get there, we need to: Group the data based on some criteria, elements of OncotreeLineage Summarize each group via a summary statistic performed on a column, such as Age. We first subset the the two columns we need, and then use the methods .group_by(x) and .mean(). metadata_grouped = metadata.groupby(&quot;OncotreeLineage&quot;) metadata_grouped[&#39;Age&#39;].mean() ## OncotreeLineage ## Adrenal Gland 55.000000 ## Ampulla of Vater 65.500000 ## Biliary Tract 58.450000 ## Bladder/Urinary Tract 65.166667 ## Bone 20.854545 ## Bowel 58.611111 ## Breast 50.961039 ## CNS/Brain 43.849057 ## Cervix 47.136364 ## Esophagus/Stomach 57.855556 ## Eye 51.100000 ## Fibroblast 38.194444 ## Head and Neck 60.149254 ## Kidney 46.193548 ## Liver 43.928571 ## Lung 55.444444 ## Lymphoid 38.916667 ## Myeloid 38.810811 ## Normal 52.370370 ## Other 46.000000 ## Ovary/Fallopian Tube 51.980769 ## Pancreas 60.226415 ## Peripheral Nervous System 5.480000 ## Pleura 61.000000 ## Prostate 61.666667 ## Skin 49.033708 ## Soft Tissue 27.500000 ## Testis 25.000000 ## Thyroid 63.235294 ## Uterus 62.060606 ## Vulva/Vagina 75.400000 ## Name: Age, dtype: float64 Here’s what’s going on: We use the Dataframe method .group_by(x) and specify the column we want to group by. The output of this method is a Grouped Dataframe object. It still contains all the information of the metadata Dataframe, but it makes a note that it’s been grouped. We subset to the column Age. The grouping information still persists (This is a Grouped Series object). We use the method .mean() to calculate the mean value of Age within each group defined by OncotreeLineage. Alternatively, this could have been done in a chain of methods: metadata.groupby(&quot;OncotreeLineage&quot;)[&quot;Age&quot;].mean() ## OncotreeLineage ## Adrenal Gland 55.000000 ## Ampulla of Vater 65.500000 ## Biliary Tract 58.450000 ## Bladder/Urinary Tract 65.166667 ## Bone 20.854545 ## Bowel 58.611111 ## Breast 50.961039 ## CNS/Brain 43.849057 ## Cervix 47.136364 ## Esophagus/Stomach 57.855556 ## Eye 51.100000 ## Fibroblast 38.194444 ## Head and Neck 60.149254 ## Kidney 46.193548 ## Liver 43.928571 ## Lung 55.444444 ## Lymphoid 38.916667 ## Myeloid 38.810811 ## Normal 52.370370 ## Other 46.000000 ## Ovary/Fallopian Tube 51.980769 ## Pancreas 60.226415 ## Peripheral Nervous System 5.480000 ## Pleura 61.000000 ## Prostate 61.666667 ## Skin 49.033708 ## Soft Tissue 27.500000 ## Testis 25.000000 ## Thyroid 63.235294 ## Uterus 62.060606 ## Vulva/Vagina 75.400000 ## Name: Age, dtype: float64 Once a Dataframe has been grouped and a column is selected, all the summary statistics methods you learned from last week, such as .mean(), .median(), .max(), can be used. One new summary statistics method that is useful for this grouping and summarizing analysis is .count() which tells you how many entries are counted within each group. 4.3.1 Optional: Multiple grouping, Multiple columns, Multiple summary statistics Sometimes, when performing grouping and summary analysis, you want to operate on multiple columns simultaneously. For example, you may want to group by a combination of OncotreeLineage and AgeCategory, such as “Lung” and “Adult” as one grouping. You can do so like this: metadata_grouped = metadata.groupby([&quot;OncotreeLineage&quot;, &quot;AgeCategory&quot;]) metadata_grouped[&#39;Age&#39;].mean() ## OncotreeLineage AgeCategory ## Adrenal Gland Adult 55.000000 ## Ampulla of Vater Adult 65.500000 ## Unknown NaN ## Biliary Tract Adult 58.450000 ## Unknown NaN ## ... ## Thyroid Unknown NaN ## Uterus Adult 62.060606 ## Fetus NaN ## Unknown NaN ## Vulva/Vagina Adult 75.400000 ## Name: Age, Length: 72, dtype: float64 You can also summarize on multiple columns simultaneously. For each column, you have to specify what summary statistic functions you want to use. This can be specified via the .agg(x) method on a Grouped Dataframe. For example, coming back to our age case-control Dataframe, df = pd.DataFrame(data={&#39;status&#39;: [&quot;treated&quot;, &quot;untreated&quot;, &quot;untreated&quot;, &quot;discharged&quot;, &quot;treated&quot;], &#39;age_case&#39;: [25, 43, 21, 65, 7], &#39;age_control&#39;: [49, 20, 32, 25, 32]}) df ## status age_case age_control ## 0 treated 25 49 ## 1 untreated 43 20 ## 2 untreated 21 32 ## 3 discharged 65 25 ## 4 treated 7 32 We group by status and summarize age_case and age_control with a few summary statistics each: df.groupby(&quot;status&quot;).agg({&quot;age_case&quot;: &quot;mean&quot;, &quot;age_control&quot;: [&quot;min&quot;, &quot;max&quot;, &quot;mean&quot;]}) ## age_case age_control ## mean min max mean ## status ## discharged 65.0 25 25 25.0 ## treated 16.0 32 49 40.5 ## untreated 32.0 20 32 26.0 The input argument to the .agg(x) method is called a Dictionary, which let’s you structure information in a paired relationship. You can learn more about dictionaries here. 4.4 Exercises Exercise for week 4 can be found here. "],["data-visualization.html", "Chapter 5 Data Visualization 5.1 Distributions (one variable) 5.2 Relational (between 2 continuous variables) 5.3 Categorical (between 1 categorical and 1 continuous variable) 5.4 Basic plot customization 5.5 Exercises", " Chapter 5 Data Visualization In our final to last week together, we learn about how to visualize our data. There are several different data visualization modules in Python: matplotlib is a general purpose plotting module that is commonly used. seaborn is a plotting module built on top of matplotlib focused on data science and statistical visualization. We will focus on this module for this course. plotnine is a plotting module based on the grammar of graphics organization of making plots. This is very similar to the R package “ggplot”. To get started, we will consider these most simple and common plots: Distributions (one variable) Histograms Relational (between 2 continuous variables) Scatterplots Line plots Categorical (between 1 categorical and 1 continuous variable) Bar plots Violin plots Why do we focus on these common plots? Our eyes are better at distinguishing certain visual features more than others. All of these plots are focused on their position to depict data, which gives us the most effective visual scale. Let’s load in our genomics datasets and start making some plots from them. import pandas as pd import seaborn as sns import matplotlib.pyplot as plt metadata = pd.read_csv(&quot;classroom_data/metadata.csv&quot;) mutation = pd.read_csv(&quot;classroom_data/mutation.csv&quot;) expression = pd.read_csv(&quot;classroom_data/expression.csv&quot;) 5.1 Distributions (one variable) To create a histogram, we use the function sns.displot() and we specify the input argument data as our dataframe, and the input argument x as the column name in a String. plot = sns.displot(data=metadata, x=&quot;Age&quot;) (For the webpage’s purpose, assign the plot to a variable plot. In practice, you don’t need to do that. You can just write sns.displot(data=metadata, x=\"Age\")). A common parameter to consider when making histogram is how big the bins are. You can specify the bin width via binwidth argument, or the number of bins via bins argument. plot = sns.displot(data=metadata, x=&quot;Age&quot;, binwidth = 10) Our histogram also works for categorical variables, such as “Sex”. plot = sns.displot(data=metadata, x=&quot;Sex&quot;) Conditioning on other variables Sometimes, you want to examine a distribution, such as Age, conditional on other variables, such as Age for Female, Age for Male, and Age for Unknown: what is the distribution of age when compared with sex? There are several ways of doing it. First, you could color variables by color, using the hue input argument: plot = sns.displot(data=metadata, x=&quot;Age&quot;, hue=&quot;Sex&quot;) It is rather hard to tell the groups apart from the coloring. So, we add a new option that we want to separate each bar category via multiple=\"dodge\" input argument: plot = sns.displot(data=metadata, x=&quot;Age&quot;, hue=&quot;Sex&quot;, multiple=&quot;dodge&quot;) Lastly, an alternative to using colors to display the conditional variable, we could make a subplot for each conditional variable’s value via col=\"Sex\" or row=\"Sex\": plot = sns.displot(data=metadata, x=&quot;Age&quot;, col=&quot;Sex&quot;) You can find a lot more details about distributions and histograms in the Seaborn tutorial. 5.2 Relational (between 2 continuous variables) To visualize two continuous variables, it is common to use a scatterplot or a lineplot. We use the function sns.relplot() and we specify the input argument data as our dataframe, and the input arguments x and y as the column names in a String: plot = sns.relplot(data=expression, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;) To conditional on other variables, plotting features are used to distinguish conditional variable values: hue (similar to the histogram) style size Let’s merge expression and metadata together, so that we can examine KRAS and EGFR relationships conditional on primary vs. metastatic cancer status. Here is the scatterplot with different color: expression_metadata = expression.merge(metadata) plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, hue=&quot;PrimaryOrMetastasis&quot;) Here is the scatterplot with different shapes: plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, style=&quot;PrimaryOrMetastasis&quot;) You can also try plotting with size=PrimaryOrMetastasis\" if you like. None of these seem pretty effective at distinguishing the two groups, so we will try subplot faceting as we did for the histogram: plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, col=&quot;PrimaryOrMetastasis&quot;) You can also conditional on multiple variables by assigning a different variable to the conditioning options: plot = sns.relplot(data=expression_metadata, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;, hue=&quot;PrimaryOrMetastasis&quot;, col=&quot;AgeCategory&quot;) You can find a lot more details about relational plots such as scatterplots and lineplots in the Seaborn tutorial. 5.3 Categorical (between 1 categorical and 1 continuous variable) A very similar pattern follows for categorical plots. We start with sns.catplot() as our main plotting function, with the basic input arguments: data x y You can change the plot styles via the input arguments: kind: “strip”, “box”, “swarm”, etc. You can add additional conditional variables via the input arguments: hue col row See categorical plots in the Seaborn tutorial. 5.4 Basic plot customization You can easily change the axis labels and title if you modify the plot object, using the method .set(): exp_plot = sns.relplot(data=expression, x=&quot;KRAS_Exp&quot;, y=&quot;EGFR_Exp&quot;) exp_plot.set(xlabel=&quot;KRAS Espression&quot;, ylabel=&quot;EGFR Expression&quot;, title=&quot;Gene expression relationship&quot;) You can change the color palette by setting adding the palette input argument to any of the plots. You can explore available color palettes here: plot = sns.displot(data=metadata, x=&quot;Age&quot;, hue=&quot;Sex&quot;, multiple=&quot;dodge&quot;, palette=sns.color_palette(palette=&#39;rainbow&#39;) ) ## &lt;string&gt;:1: UserWarning: The palette list has more values (6) than needed (3), which may not be intended. 5.5 Exercises Exercise for week 5 can be found here. "],["about-the-authors.html", "About the Authors", " About the Authors These credits are based on our course contributors table guidelines.     Credits Names Pedagogy Lead Content Instructor(s) FirstName LastName Lecturer(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved Delivered the course in some way - video or audio Content Author(s) (include chapter name/link in parentheses if only for specific chapters) - make new line if more than one chapter involved If any other authors besides lead instructor Content Contributor(s) (include section name/link in parentheses) - make new line if more than one section involved Wrote less than a chapter Content Editor(s)/Reviewer(s) Checked your content Content Director(s) Helped guide the content direction Content Consultants (include chapter name/link in parentheses or word “General”) - make new line if more than one chapter involved Gave high level advice on content Acknowledgments Gave small assistance to content but not to the level of consulting Production Content Publisher(s) Helped with publishing platform Content Publishing Reviewer(s) Reviewed overall content and aesthetics on publishing platform Technical Course Publishing Engineer(s) Helped with the code for the technical aspects related to the specific course generation Template Publishing Engineers Candace Savonen, Carrie Wright, Ava Hoffman Publishing Maintenance Engineer Candace Savonen Technical Publishing Stylists Carrie Wright, Ava Hoffman, Candace Savonen Package Developers (ottrpal) Candace Savonen, John Muschelli, Carrie Wright Art and Design Illustrator(s) Created graphics for the course Figure Artist(s) Created figures/plots for course Videographer(s) Filmed videos Videography Editor(s) Edited film Audiographer(s) Recorded audio Audiography Editor(s) Edited audio recordings Funding Funder(s) Institution/individual who funded course including grant number Funding Staff Staff members who help with funding   ## ─ Session info ─────────────────────────────────────────────────────────────── ## setting value ## version R version 4.3.2 (2023-10-31) ## os Ubuntu 22.04.4 LTS ## system x86_64, linux-gnu ## ui X11 ## language (EN) ## collate en_US.UTF-8 ## ctype en_US.UTF-8 ## tz Etc/UTC ## date 2024-09-26 ## pandoc 3.1.1 @ /usr/local/bin/ (via rmarkdown) ## ## ─ Packages ─────────────────────────────────────────────────────────────────── ## package * version date (UTC) lib source ## bookdown 0.39.1 2024-06-11 [1] Github (rstudio/bookdown@f244cf1) ## bslib 0.6.1 2023-11-28 [1] RSPM (R 4.3.0) ## cachem 1.0.8 2023-05-01 [1] RSPM (R 4.3.0) ## cli 3.6.2 2023-12-11 [1] RSPM (R 4.3.0) ## devtools 2.4.5 2022-10-11 [1] RSPM (R 4.3.0) ## digest 0.6.34 2024-01-11 [1] RSPM (R 4.3.0) ## ellipsis 0.3.2 2021-04-29 [1] RSPM (R 4.3.0) ## evaluate 0.23 2023-11-01 [1] RSPM (R 4.3.0) ## fastmap 1.1.1 2023-02-24 [1] RSPM (R 4.3.0) ## fs 1.6.3 2023-07-20 [1] RSPM (R 4.3.0) ## glue 1.7.0 2024-01-09 [1] RSPM (R 4.3.0) ## htmltools 0.5.7 2023-11-03 [1] RSPM (R 4.3.0) ## htmlwidgets 1.6.4 2023-12-06 [1] RSPM (R 4.3.0) ## httpuv 1.6.14 2024-01-26 [1] RSPM (R 4.3.0) ## jquerylib 0.1.4 2021-04-26 [1] RSPM (R 4.3.0) ## jsonlite 1.8.8 2023-12-04 [1] RSPM (R 4.3.0) ## knitr 1.47.3 2024-06-11 [1] Github (yihui/knitr@e1edd34) ## later 1.3.2 2023-12-06 [1] RSPM (R 4.3.0) ## lifecycle 1.0.4 2023-11-07 [1] RSPM (R 4.3.0) ## magrittr 2.0.3 2022-03-30 [1] RSPM (R 4.3.0) ## memoise 2.0.1 2021-11-26 [1] RSPM (R 4.3.0) ## mime 0.12 2021-09-28 [1] RSPM (R 4.3.0) ## miniUI 0.1.1.1 2018-05-18 [1] RSPM (R 4.3.0) ## pkgbuild 1.4.3 2023-12-10 [1] RSPM (R 4.3.0) ## pkgload 1.3.4 2024-01-16 [1] RSPM (R 4.3.0) ## profvis 0.3.8 2023-05-02 [1] RSPM (R 4.3.0) ## promises 1.2.1 2023-08-10 [1] RSPM (R 4.3.0) ## purrr 1.0.2 2023-08-10 [1] RSPM (R 4.3.0) ## R6 2.5.1 2021-08-19 [1] RSPM (R 4.3.0) ## Rcpp 1.0.12 2024-01-09 [1] RSPM (R 4.3.0) ## remotes 2.4.2.1 2023-07-18 [1] RSPM (R 4.3.0) ## rlang 1.1.4 2024-06-04 [1] CRAN (R 4.3.2) ## rmarkdown 2.27.1 2024-06-11 [1] Github (rstudio/rmarkdown@e1c93a9) ## sass 0.4.8 2023-12-06 [1] RSPM (R 4.3.0) ## sessioninfo 1.2.2 2021-12-06 [1] RSPM (R 4.3.0) ## shiny 1.8.0 2023-11-17 [1] RSPM (R 4.3.0) ## stringi 1.8.3 2023-12-11 [1] RSPM (R 4.3.0) ## stringr 1.5.1 2023-11-14 [1] RSPM (R 4.3.0) ## urlchecker 1.0.1 2021-11-30 [1] RSPM (R 4.3.0) ## usethis 2.2.3 2024-02-19 [1] RSPM (R 4.3.0) ## vctrs 0.6.5 2023-12-01 [1] RSPM (R 4.3.0) ## xfun 0.44.4 2024-06-11 [1] Github (yihui/xfun@9da62cc) ## xtable 1.8-4 2019-04-21 [1] RSPM (R 4.3.0) ## yaml 2.3.8 2023-12-11 [1] RSPM (R 4.3.0) ## ## [1] /usr/local/lib/R/site-library ## [2] /usr/local/lib/R/library ## ## ────────────────────────────────────────────────────────────────────────────── "],["references.html", "Chapter 6 References", " Chapter 6 References "],["404.html", "Page not found", " Page not found The page you requested cannot be found (perhaps it was moved or renamed). You may want to try searching to find the page's new location, or use the table of contents to find the page you are looking for. "]]
diff --git a/docs/working-with-data-structures.html b/docs/working-with-data-structures.html
new file mode 100644
index 0000000..9cb49e5
--- /dev/null
+++ b/docs/working-with-data-structures.html
@@ -0,0 +1,603 @@
+<!DOCTYPE html>
+<html lang="" xml:lang="">
+<head>
+
+  <meta charset="utf-8" />
+  <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+  <title>Chapter 2 Working with data structures | Introduction to Python</title>
+  <meta name="description" content="Description about Course/Book." />
+  <meta name="generator" content="bookdown 0.39.1 and GitBook 2.6.7" />
+
+  <meta property="og:title" content="Chapter 2 Working with data structures | Introduction to Python" />
+  <meta property="og:type" content="book" />
+  
+  <meta property="og:description" content="Description about Course/Book." />
+  
+
+  <meta name="twitter:card" content="summary" />
+  <meta name="twitter:title" content="Chapter 2 Working with data structures | Introduction to Python" />
+  
+  <meta name="twitter:description" content="Description about Course/Book." />
+  
+
+
+
+
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="apple-mobile-web-app-capable" content="yes" />
+  <meta name="apple-mobile-web-app-status-bar-style" content="black" />
+  
+  <link rel="shortcut icon" href="assets/dasl_favicon.ico" type="image/x-icon" />
+<link rel="prev" href="intro-to-computing.html"/>
+<link rel="next" href="data-wrangling-part-1.html"/>
+<script src="libs/jquery-3.6.0/jquery-3.6.0.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/fuse.js@6.4.6/dist/fuse.min.js"></script>
+<link href="libs/gitbook-2.6.7/css/style.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-table.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-bookdown.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-highlight.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-search.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-fontsettings.css" rel="stylesheet" />
+<link href="libs/gitbook-2.6.7/css/plugin-clipboard.css" rel="stylesheet" />
+
+
+
+
+
+
+
+
+<link href="libs/anchor-sections-1.1.0/anchor-sections.css" rel="stylesheet" />
+<link href="libs/anchor-sections-1.1.0/anchor-sections-hash.css" rel="stylesheet" />
+<script src="libs/anchor-sections-1.1.0/anchor-sections.js"></script>
+
+
+<style type="text/css">
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+  { counter-reset: source-line 0; }
+pre.numberSource code > span
+  { position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+  { content: counter(source-line);
+    position: relative; left: -1em; text-align: right; vertical-align: baseline;
+    border: none; display: inline-block;
+    -webkit-touch-callout: none; -webkit-user-select: none;
+    -khtml-user-select: none; -moz-user-select: none;
+    -ms-user-select: none; user-select: none;
+    padding: 0 4px; width: 4em;
+    color: #aaaaaa;
+  }
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa;  padding-left: 4px; }
+div.sourceCode
+  {  background-color: #f8f8f8; }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ef2929; } /* Alert */
+code span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
+code span.at { color: #204a87; } /* Attribute */
+code span.bn { color: #0000cf; } /* BaseN */
+code span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
+code span.ch { color: #4e9a06; } /* Char */
+code span.cn { color: #8f5902; } /* Constant */
+code span.co { color: #8f5902; font-style: italic; } /* Comment */
+code span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
+code span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
+code span.dt { color: #204a87; } /* DataType */
+code span.dv { color: #0000cf; } /* DecVal */
+code span.er { color: #a40000; font-weight: bold; } /* Error */
+code span.ex { } /* Extension */
+code span.fl { color: #0000cf; } /* Float */
+code span.fu { color: #204a87; font-weight: bold; } /* Function */
+code span.im { } /* Import */
+code span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
+code span.kw { color: #204a87; font-weight: bold; } /* Keyword */
+code span.op { color: #ce5c00; font-weight: bold; } /* Operator */
+code span.ot { color: #8f5902; } /* Other */
+code span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
+code span.sc { color: #ce5c00; font-weight: bold; } /* SpecialChar */
+code span.ss { color: #4e9a06; } /* SpecialString */
+code span.st { color: #4e9a06; } /* String */
+code span.va { color: #000000; } /* Variable */
+code span.vs { color: #4e9a06; } /* VerbatimString */
+code span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
+</style>
+
+<style type="text/css">
+  
+  div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+</style>
+
+<link rel="stylesheet" href="assets/style.css" type="text/css" />
+</head>
+
+<body>
+
+
+
+  <div class="book without-animation with-summary font-size-2 font-family-1" data-basepath=".">
+
+    <div class="book-summary">
+      <nav role="navigation">
+
+<ul class="summary">
+<a href="https://hutchdatascience.org/" target="_blank"><img src="assets/big-dasl-stacked.png" style="width: 80%; padding-left: 34px; padding-top: 8px;"</a>
+
+<li class="divider"></li>
+<li class="chapter" data-level="" data-path="index.html"><a href="index.html"><i class="fa fa-check"></i>About this Course</a>
+<ul>
+<li class="chapter" data-level="0.1" data-path="index.html"><a href="index.html#curriculum"><i class="fa fa-check"></i><b>0.1</b> Curriculum</a></li>
+<li class="chapter" data-level="0.2" data-path="index.html"><a href="index.html#target-audience"><i class="fa fa-check"></i><b>0.2</b> Target Audience</a></li>
+<li class="chapter" data-level="0.3" data-path="index.html"><a href="index.html#learning-objectives"><i class="fa fa-check"></i><b>0.3</b> Learning Objectives</a></li>
+<li class="chapter" data-level="0.4" data-path="index.html"><a href="index.html#offerings"><i class="fa fa-check"></i><b>0.4</b> Offerings</a></li>
+</ul></li>
+<li class="chapter" data-level="1" data-path="intro-to-computing.html"><a href="intro-to-computing.html"><i class="fa fa-check"></i><b>1</b> Intro to Computing</a>
+<ul>
+<li class="chapter" data-level="1.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#goals-of-the-course"><i class="fa fa-check"></i><b>1.1</b> Goals of the course</a></li>
+<li class="chapter" data-level="1.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#what-is-a-computer-program"><i class="fa fa-check"></i><b>1.2</b> What is a computer program?</a></li>
+<li class="chapter" data-level="1.3" data-path="intro-to-computing.html"><a href="intro-to-computing.html#a-programming-language-has-following-elements"><i class="fa fa-check"></i><b>1.3</b> A programming language has following elements:</a></li>
+<li class="chapter" data-level="1.4" data-path="intro-to-computing.html"><a href="intro-to-computing.html#google-colab-setup"><i class="fa fa-check"></i><b>1.4</b> Google Colab Setup</a></li>
+<li class="chapter" data-level="1.5" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-1-evaluation-of-expressions"><i class="fa fa-check"></i><b>1.5</b> Grammar Structure 1: Evaluation of Expressions</a>
+<ul>
+<li class="chapter" data-level="1.5.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#function-machine-schema"><i class="fa fa-check"></i><b>1.5.1</b> Function machine schema</a></li>
+<li class="chapter" data-level="1.5.2" data-path="intro-to-computing.html"><a href="intro-to-computing.html#data-types"><i class="fa fa-check"></i><b>1.5.2</b> Data types</a></li>
+</ul></li>
+<li class="chapter" data-level="1.6" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-2-storing-data-types-in-the-variable-environment"><i class="fa fa-check"></i><b>1.6</b> Grammar Structure 2: Storing data types in the Variable Environment</a>
+<ul>
+<li class="chapter" data-level="1.6.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-variable-assignment"><i class="fa fa-check"></i><b>1.6.1</b> Execution rule for variable assignment</a></li>
+</ul></li>
+<li class="chapter" data-level="1.7" data-path="intro-to-computing.html"><a href="intro-to-computing.html#grammar-structure-3-evaluation-of-functions"><i class="fa fa-check"></i><b>1.7</b> Grammar Structure 3: Evaluation of Functions</a>
+<ul>
+<li class="chapter" data-level="1.7.1" data-path="intro-to-computing.html"><a href="intro-to-computing.html#execution-rule-for-functions"><i class="fa fa-check"></i><b>1.7.1</b> Execution rule for functions:</a></li>
+</ul></li>
+<li class="chapter" data-level="1.8" data-path="intro-to-computing.html"><a href="intro-to-computing.html#tips-on-writing-your-first-code"><i class="fa fa-check"></i><b>1.8</b> Tips on writing your first code</a></li>
+<li class="chapter" data-level="1.9" data-path="intro-to-computing.html"><a href="intro-to-computing.html#exercises"><i class="fa fa-check"></i><b>1.9</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html"><i class="fa fa-check"></i><b>2</b> Working with data structures</a>
+<ul>
+<li class="chapter" data-level="2.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#lists"><i class="fa fa-check"></i><b>2.1</b> Lists</a>
+<ul>
+<li class="chapter" data-level="2.1.1" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-lists"><i class="fa fa-check"></i><b>2.1.1</b> Subsetting lists</a></li>
+<li class="chapter" data-level="2.1.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists"><i class="fa fa-check"></i><b>2.1.2</b> Subsetting multiple elements of lists</a></li>
+</ul></li>
+<li class="chapter" data-level="2.2" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#objects-in-python"><i class="fa fa-check"></i><b>2.2</b> Objects in Python</a></li>
+<li class="chapter" data-level="2.3" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#methods-vs-functions"><i class="fa fa-check"></i><b>2.3</b> Methods vs Functions</a></li>
+<li class="chapter" data-level="2.4" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#dataframes"><i class="fa fa-check"></i><b>2.4</b> Dataframes</a></li>
+<li class="chapter" data-level="2.5" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-does-a-dataframe-contain"><i class="fa fa-check"></i><b>2.5</b> What does a Dataframe contain?</a></li>
+<li class="chapter" data-level="2.6" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#what-can-a-dataframe-do"><i class="fa fa-check"></i><b>2.6</b> What can a Dataframe do?</a></li>
+<li class="chapter" data-level="2.7" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#subsetting-dataframes"><i class="fa fa-check"></i><b>2.7</b> Subsetting Dataframes</a></li>
+<li class="chapter" data-level="2.8" data-path="working-with-data-structures.html"><a href="working-with-data-structures.html#exercises-1"><i class="fa fa-check"></i><b>2.8</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html"><i class="fa fa-check"></i><b>3</b> Data Wrangling, Part 1</a>
+<ul>
+<li class="chapter" data-level="3.1" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#tidy-data"><i class="fa fa-check"></i><b>3.1</b> Tidy Data</a></li>
+<li class="chapter" data-level="3.2" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#our-working-tidy-data-depmap-project"><i class="fa fa-check"></i><b>3.2</b> Our working Tidy Data: DepMap Project</a></li>
+<li class="chapter" data-level="3.3" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#transform-what-do-you-want-to-do-with-this-dataframe"><i class="fa fa-check"></i><b>3.3</b> Transform: “What do you want to do with this Dataframe”?</a></li>
+<li class="chapter" data-level="3.4" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#summary-statistics"><i class="fa fa-check"></i><b>3.4</b> Summary Statistics</a></li>
+<li class="chapter" data-level="3.5" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#simple-data-visualization"><i class="fa fa-check"></i><b>3.5</b> Simple data visualization</a></li>
+<li class="chapter" data-level="3.6" data-path="data-wrangling-part-1.html"><a href="data-wrangling-part-1.html#exercises-2"><i class="fa fa-check"></i><b>3.6</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html"><i class="fa fa-check"></i><b>4</b> Data Wrangling, Part 2</a>
+<ul>
+<li class="chapter" data-level="4.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#creating-new-columns"><i class="fa fa-check"></i><b>4.1</b> Creating new columns</a></li>
+<li class="chapter" data-level="4.2" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#merging-two-dataframes-together"><i class="fa fa-check"></i><b>4.2</b> Merging two Dataframes together</a></li>
+<li class="chapter" data-level="4.3" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#grouping-and-summarizing-dataframes"><i class="fa fa-check"></i><b>4.3</b> Grouping and summarizing Dataframes</a>
+<ul>
+<li class="chapter" data-level="4.3.1" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#optional-multiple-grouping-multiple-columns-multiple-summary-statistics"><i class="fa fa-check"></i><b>4.3.1</b> Optional: Multiple grouping, Multiple columns, Multiple summary statistics</a></li>
+</ul></li>
+<li class="chapter" data-level="4.4" data-path="data-wrangling-part-2.html"><a href="data-wrangling-part-2.html#exercises-3"><i class="fa fa-check"></i><b>4.4</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="5" data-path="data-visualization.html"><a href="data-visualization.html"><i class="fa fa-check"></i><b>5</b> Data Visualization</a>
+<ul>
+<li class="chapter" data-level="5.1" data-path="data-visualization.html"><a href="data-visualization.html#distributions-one-variable"><i class="fa fa-check"></i><b>5.1</b> Distributions (one variable)</a></li>
+<li class="chapter" data-level="5.2" data-path="data-visualization.html"><a href="data-visualization.html#relational-between-2-continuous-variables"><i class="fa fa-check"></i><b>5.2</b> Relational (between 2 continuous variables)</a></li>
+<li class="chapter" data-level="5.3" data-path="data-visualization.html"><a href="data-visualization.html#categorical-between-1-categorical-and-1-continuous-variable"><i class="fa fa-check"></i><b>5.3</b> Categorical (between 1 categorical and 1 continuous variable)</a></li>
+<li class="chapter" data-level="5.4" data-path="data-visualization.html"><a href="data-visualization.html#basic-plot-customization"><i class="fa fa-check"></i><b>5.4</b> Basic plot customization</a></li>
+<li class="chapter" data-level="5.5" data-path="data-visualization.html"><a href="data-visualization.html#exercises-4"><i class="fa fa-check"></i><b>5.5</b> Exercises</a></li>
+</ul></li>
+<li class="chapter" data-level="" data-path="about-the-authors.html"><a href="about-the-authors.html"><i class="fa fa-check"></i>About the Authors</a></li>
+<li class="chapter" data-level="6" data-path="references.html"><a href="references.html"><i class="fa fa-check"></i><b>6</b> References</a></li>
+<li class="divider"></li>
+<p style="text-align:center;"> <a href="https://github.com/jhudsl/OTTR_Template" target="blank" > This content was published with</a> <a href="https://bookdown.org/" target="blank"> bookdown by: </a> </p>
+<p style="text-align:center;"> <a href="https://hutchdatascience.org/"> The Fred Hutch Data Science Lab </a></p>
+<p style="text-align:center; font-size: 12px;"> <a href="https://github.com/rstudio4edu/rstudio4edu-book/"> Style adapted from: rstudio4edu-book </a> <a href ="https://creativecommons.org/licenses/by/2.0/"> (CC-BY 2.0) </a></p>
+<p style="padding-left: 40px;"><div class="trapezoid" style = "padding-left: 40px;"><span>  <a href="https://forms.gle/W6Mg4rzuMK6Yk3Am8"> Click here to provide feedback</a> <img src="assets/itcr_arrow.png" style=" width: 10%" ></span></div></p>
+</ul>
+
+      </nav>
+    </div>
+
+    <div class="book-body">
+      <div class="body-inner">
+        <div class="book-header" role="navigation">
+          <h1>
+            <i class="fa fa-circle-o-notch fa-spin"></i><a href="./">Introduction to Python</a>
+          </h1>
+        </div>
+
+        <div class="page-wrapper" tabindex="-1" role="main">
+          <div class="page-inner">
+
+            <section class="normal" id="section-">
+<head>
+  <meta name="viewport" content="width=device-width,minimum-scale=1.0,maximum-scale=10.0,initial-scale=1.0">
+  <!--script src="https://kit.fontawesome.com/6a26f47516.js"></script-->
+  <!--<script src="assets/hideOutput.js"></script>-->
+  <link href="assets/style.css" rel="stylesheet">
+</head>
+        
+
+
+<div class="hero-image-container"> 
+  <img class= "hero-image" src="assets/dasl_thin_main_image.png">
+</div>
+<div id="working-with-data-structures" class="section level1 hasAnchor" number="2">
+<h1><span class="header-section-number">Chapter 2</span> Working with data structures<a href="working-with-data-structures.html#working-with-data-structures" class="anchor-section" aria-label="Anchor link to header"></a></h1>
+<p>In our second lesson, we start to look at two <strong>data structures</strong>, <strong>Lists</strong> and <strong>Dataframes</strong>, that can handle a large amount of data for analysis.</p>
+<div id="lists" class="section level2 hasAnchor" number="2.1">
+<h2><span class="header-section-number">2.1</span> Lists<a href="working-with-data-structures.html#lists" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>In the first exercise, you started to explore <strong>data structures</strong>, which store information about data types. You explored <strong>lists</strong>, which is an ordered collection of data types or data structures. Each <em>element</em> of a list contains a data type or another data structure.</p>
+<p>We can now store a vast amount of information in a list, and assign it to a single variable. Even more, we can use operations and functions on a list, modifying many elements within the list at once! This makes analyzing data much more scalable and less repetitive.</p>
+<p>We create a list via the bracket <code>[ ]</code> operation.</p>
+<div class="sourceCode" id="cb36"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb36-1"><a href="working-with-data-structures.html#cb36-1" tabindex="-1"></a>staff <span class="op">=</span> [<span class="st">&quot;chris&quot;</span>, <span class="st">&quot;ted&quot;</span>, <span class="st">&quot;jeff&quot;</span>]</span>
+<span id="cb36-2"><a href="working-with-data-structures.html#cb36-2" tabindex="-1"></a>chrNum <span class="op">=</span> [<span class="dv">2</span>, <span class="dv">3</span>, <span class="dv">1</span>, <span class="dv">2</span>, <span class="dv">2</span>]</span>
+<span id="cb36-3"><a href="working-with-data-structures.html#cb36-3" tabindex="-1"></a>mixedList <span class="op">=</span> [<span class="va">False</span>, <span class="va">False</span>, <span class="va">False</span>, <span class="st">&quot;A&quot;</span>, <span class="st">&quot;B&quot;</span>, <span class="dv">92</span>]</span></code></pre></div>
+<div id="subsetting-lists" class="section level3 hasAnchor" number="2.1.1">
+<h3><span class="header-section-number">2.1.1</span> Subsetting lists<a href="working-with-data-structures.html#subsetting-lists" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>To access an element of a list, you can use the bracket notation <code>[ ]</code> to access the elements of the list. We simply access an element via the “index” number - the location of the data within the list.</p>
+<p><em>Here’s the tricky thing about the index number: it starts at 0!</em></p>
+<p>1st element of <code>chrNum</code>: <code>chrNum[0]</code></p>
+<p>2nd element of <code>chrNum</code>: <code>chrNum[1]</code></p>
+<p>…</p>
+<p>5th element of <code>chrNum</code>: <code>chrNum[4]</code></p>
+<p>With subsetting, you can modify elements of a list or use the element of a list as part of an expression.</p>
+</div>
+<div id="subsetting-multiple-elements-of-lists" class="section level3 hasAnchor" number="2.1.2">
+<h3><span class="header-section-number">2.1.2</span> Subsetting multiple elements of lists<a href="working-with-data-structures.html#subsetting-multiple-elements-of-lists" class="anchor-section" aria-label="Anchor link to header"></a></h3>
+<p>Suppose you want to access multiple elements of a list, such as accessing the first three elements of <code>chrNum</code>. You would use the <strong>slice</strong> operator <code>:</code>, which specifies:</p>
+<ul>
+<li><p>the index number to start</p></li>
+<li><p>the index number to stop, <em>plus one.</em></p></li>
+</ul>
+<p>If you want to access the first three elements of <code>chrNum</code>:</p>
+<div class="sourceCode" id="cb37"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb37-1"><a href="working-with-data-structures.html#cb37-1" tabindex="-1"></a>chrNum[<span class="dv">0</span>:<span class="dv">3</span>]</span></code></pre></div>
+<pre><code>## [2, 3, 1]</code></pre>
+<p>The first element’s index number is 0, the third element’s index number is 2, plus 1, which is 3.</p>
+<p>If you want to access the second and third elements of <code>chrNum</code>:</p>
+<div class="sourceCode" id="cb39"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb39-1"><a href="working-with-data-structures.html#cb39-1" tabindex="-1"></a>chrNum[<span class="dv">1</span>:<span class="dv">3</span>]</span></code></pre></div>
+<pre><code>## [3, 1]</code></pre>
+<p>Another way of accessing the first 3 elements of <code>chrNum</code>:</p>
+<div class="sourceCode" id="cb41"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb41-1"><a href="working-with-data-structures.html#cb41-1" tabindex="-1"></a>chrNum[:<span class="dv">3</span>]</span></code></pre></div>
+<pre><code>## [2, 3, 1]</code></pre>
+<p>Here, the start index number was not specified. When the start or stop index is <em>not</em> specified, it implies that you are subsetting starting the from the beginning of the list or subsetting to the end of the list, respectively. Here’s another example, using negative indicies to count from 3 elements from the end of the list:</p>
+<div class="sourceCode" id="cb43"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb43-1"><a href="working-with-data-structures.html#cb43-1" tabindex="-1"></a>chrNum[<span class="op">-</span><span class="dv">3</span>:]</span></code></pre></div>
+<pre><code>## [1, 2, 2]</code></pre>
+<p>You can find more discussion of list slicing, using negative indicies and incremental slicing, <a href="https://towardsdatascience.com/the-basics-of-indexing-and-slicing-python-lists-2d12c90a94cf">here</a>.</p>
+</div>
+</div>
+<div id="objects-in-python" class="section level2 hasAnchor" number="2.2">
+<h2><span class="header-section-number">2.2</span> Objects in Python<a href="working-with-data-structures.html#objects-in-python" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>The list data structure has an organization and functionality that metaphorically represents a pen-and-paper list in our physical world. Like a physical object, we have examined:</p>
+<ul>
+<li><p>What does it contain (in terms of data)?</p></li>
+<li><p>What can it do (in terms of functions)?</p></li>
+</ul>
+<p>And if it “makes sense” to us, then it is well-designed.</p>
+<p>The list data structure we have been working with is an example of an <strong>Object</strong>. The definition of an object allows us to ask the questions above: <em>what does it contain, and what can it do?</em> It is an organizational tool for a collection of data and functions that we can relate to, like a physical object. Formally, an object contains the following:</p>
+<ul>
+<li><p><strong>Value</strong> that holds the essential data for the object.</p></li>
+<li><p><strong>Attributes</strong> that hold subset or additional data for the object.</p></li>
+<li><p>Functions called <strong>Methods</strong> that are for the object and <em>have to</em> take in the variable referenced as an input</p></li>
+</ul>
+<p>This organizing structure on an object applies to pretty much all Python data types and data structures.</p>
+<p>Let’s see how this applies to the list:</p>
+<ul>
+<li><p><strong>Value</strong>: the contents of the list, such as <code>[2, 3, 4].</code></p></li>
+<li><p><strong>Attributes</strong> that store additional values: Not relevant for lists.</p></li>
+<li><p><strong>Methods</strong> that can be used on the object: <code>chrNum.count(2)</code> counts the number of instances 2 appears as an element of <code>chrNum</code>.</p></li>
+</ul>
+<p>Object methods are functions that does something with the object you are using it on. You should think about <code>chrNum.count(2)</code> as a function that takes in <code>chrNum</code> and <code>2</code> as inputs. If you want to use the count function on list <code>mixedList</code>, you would use <code>mixedList.count(x)</code>.</p>
+<p>Here are some more examples of methods with lists:</p>
+<table>
+<colgroup>
+<col width="20%" />
+<col width="20%" />
+<col width="37%" />
+<col width="20%" />
+</colgroup>
+<thead>
+<tr class="header">
+<th>Function method</th>
+<th>What it takes in</th>
+<th>What it does</th>
+<th>Returns</th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.count(x)</code></a></td>
+<td>list <code>chrNum</code>, data type <code>x</code></td>
+<td>Counts the number of instances <code>x</code> appears as an element of <code>chrNum</code>.</td>
+<td>Integer</td>
+</tr>
+<tr class="even">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.append(x)</code></a></td>
+<td>list <code>chrNum</code>, data type <code>x</code></td>
+<td>Appends <code>x</code> to the end of the <code>chrNum</code>.</td>
+<td>None (but <code>chrNum</code> is modified!)</td>
+</tr>
+<tr class="odd">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.sort()</code></a></td>
+<td>list <code>chrNum</code></td>
+<td>Sorts <code>chrNum</code> by ascending order.</td>
+<td>None (but <code>chrNum</code> is modified!)</td>
+</tr>
+<tr class="even">
+<td><a href="https://docs.python.org/3/tutorial/datastructures.html"><code>chrNum.reverse()</code></a></td>
+<td>list <code>chrNum</code></td>
+<td>Reverses the order of <code>chrNum</code>.</td>
+<td>None (but <code>chrNum</code> is modified!)</td>
+</tr>
+</tbody>
+</table>
+</div>
+<div id="methods-vs-functions" class="section level2 hasAnchor" number="2.3">
+<h2><span class="header-section-number">2.3</span> Methods vs Functions<a href="working-with-data-structures.html#methods-vs-functions" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p><strong>Methods</strong> <em>have to</em> take in the object of interest as an input: <code>chrNum.count(2)</code> automatically treat <code>chrNum</code> as an input. Methods are built for a specific Object type.</p>
+<p><strong>Functions</strong> do not have an implied input: <code>len(chrNum)</code> requires specifying a list in the input.</p>
+<p>Otherwise, there is no strong distinction between the two.</p>
+</div>
+<div id="dataframes" class="section level2 hasAnchor" number="2.4">
+<h2><span class="header-section-number">2.4</span> Dataframes<a href="working-with-data-structures.html#dataframes" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>A Dataframe is a two-dimensional data structure that stores data like a spreadsheet does.</p>
+<p>The Dataframe data structure is found within a Python module called “Pandas”. A Python module is an organized collection of functions and data structures. The <code>import</code> statement below gives us permission to access the “Pandas” module via the variable <code>pd</code>.</p>
+<p>To load in a Dataframe from existing spreadsheet data, we use the function <a href="https://pandas.pydata.org/docs/reference/api/pandas.read_csv.html"><code>pd.read_csv()</code></a>:</p>
+<div class="sourceCode" id="cb45"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb45-1"><a href="working-with-data-structures.html#cb45-1" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb45-2"><a href="working-with-data-structures.html#cb45-2" tabindex="-1"></a></span>
+<span id="cb45-3"><a href="working-with-data-structures.html#cb45-3" tabindex="-1"></a>metadata <span class="op">=</span> pd.read_csv(<span class="st">&quot;classroom_data/metadata.csv&quot;</span>)</span>
+<span id="cb45-4"><a href="working-with-data-structures.html#cb45-4" tabindex="-1"></a><span class="bu">type</span>(metadata)</span></code></pre></div>
+<pre><code>## &lt;class &#39;pandas.core.frame.DataFrame&#39;&gt;</code></pre>
+<p>There is a similar function <a href="https://pandas.pydata.org/docs/reference/api/pandas.read_excel.html"><code>pd.read_excel()</code></a> for loading in Excel spreadsheets.</p>
+<p>Let’s investigate the Dataframe as an object:</p>
+<ul>
+<li><p>What does a Dataframe contain (values, attributes)?</p></li>
+<li><p>What can a Dataframe do (methods)?</p></li>
+</ul>
+</div>
+<div id="what-does-a-dataframe-contain" class="section level2 hasAnchor" number="2.5">
+<h2><span class="header-section-number">2.5</span> What does a Dataframe contain?<a href="working-with-data-structures.html#what-does-a-dataframe-contain" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>We first take a look at the contents:</p>
+<div class="sourceCode" id="cb47"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb47-1"><a href="working-with-data-structures.html#cb47-1" tabindex="-1"></a>metadata</span></code></pre></div>
+<pre><code>##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]</code></pre>
+<p>It looks like there are 1864 rows and 30 columns in this Dataframe, and when we display it it shows some of the data.</p>
+<div class="sourceCode" id="cb49"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb49-1"><a href="working-with-data-structures.html#cb49-1" tabindex="-1"></a>metadata</span></code></pre></div>
+<pre><code>##          ModelID  ...       OncotreeLineage
+## 0     ACH-000001  ...  Ovary/Fallopian Tube
+## 1     ACH-000002  ...               Myeloid
+## 2     ACH-000003  ...                 Bowel
+## 3     ACH-000004  ...               Myeloid
+## 4     ACH-000005  ...               Myeloid
+## ...          ...  ...                   ...
+## 1859  ACH-002968  ...     Esophagus/Stomach
+## 1860  ACH-002972  ...     Esophagus/Stomach
+## 1861  ACH-002979  ...     Esophagus/Stomach
+## 1862  ACH-002981  ...     Esophagus/Stomach
+## 1863  ACH-003071  ...                  Lung
+## 
+## [1864 rows x 30 columns]</code></pre>
+<p>We can look at specific columns by looking at <strong>attributes</strong> via the dot operation. We can also look at the columns via the bracket operation.</p>
+<div class="sourceCode" id="cb51"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb51-1"><a href="working-with-data-structures.html#cb51-1" tabindex="-1"></a>metadata.ModelID</span></code></pre></div>
+<pre><code>## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object</code></pre>
+<div class="sourceCode" id="cb53"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb53-1"><a href="working-with-data-structures.html#cb53-1" tabindex="-1"></a>metadata[<span class="st">&#39;ModelID&#39;</span>]</span></code></pre></div>
+<pre><code>## 0       ACH-000001
+## 1       ACH-000002
+## 2       ACH-000003
+## 3       ACH-000004
+## 4       ACH-000005
+##            ...    
+## 1859    ACH-002968
+## 1860    ACH-002972
+## 1861    ACH-002979
+## 1862    ACH-002981
+## 1863    ACH-003071
+## Name: ModelID, Length: 1864, dtype: object</code></pre>
+<p>The names of all columns is stored as an attribute, which can be accessed via the dot operation.</p>
+<div class="sourceCode" id="cb55"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb55-1"><a href="working-with-data-structures.html#cb55-1" tabindex="-1"></a>metadata.columns</span></code></pre></div>
+<pre><code>## Index([&#39;ModelID&#39;, &#39;PatientID&#39;, &#39;CellLineName&#39;, &#39;StrippedCellLineName&#39;, &#39;Age&#39;,
+##        &#39;SourceType&#39;, &#39;SangerModelID&#39;, &#39;RRID&#39;, &#39;DepmapModelType&#39;, &#39;AgeCategory&#39;,
+##        &#39;GrowthPattern&#39;, &#39;LegacyMolecularSubtype&#39;, &#39;PrimaryOrMetastasis&#39;,
+##        &#39;SampleCollectionSite&#39;, &#39;Sex&#39;, &#39;SourceDetail&#39;, &#39;LegacySubSubtype&#39;,
+##        &#39;CatalogNumber&#39;, &#39;CCLEName&#39;, &#39;COSMICID&#39;, &#39;PublicComments&#39;,
+##        &#39;WTSIMasterCellID&#39;, &#39;EngineeredModel&#39;, &#39;TreatmentStatus&#39;,
+##        &#39;OnboardedMedia&#39;, &#39;PlateCoating&#39;, &#39;OncotreeCode&#39;, &#39;OncotreeSubtype&#39;,
+##        &#39;OncotreePrimaryDisease&#39;, &#39;OncotreeLineage&#39;],
+##       dtype=&#39;object&#39;)</code></pre>
+<p>The number of rows and columns are also stored as an attribute:</p>
+<div class="sourceCode" id="cb57"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb57-1"><a href="working-with-data-structures.html#cb57-1" tabindex="-1"></a>metadata.shape</span></code></pre></div>
+<pre><code>## (1864, 30)</code></pre>
+</div>
+<div id="what-can-a-dataframe-do" class="section level2 hasAnchor" number="2.6">
+<h2><span class="header-section-number">2.6</span> What can a Dataframe do?<a href="working-with-data-structures.html#what-can-a-dataframe-do" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>We can use the <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.head.html"><code>.head()</code></a> and <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.tail.html"><code>.tail()</code></a> methods to look at the first few rows and last few rows of <code>metadata</code>, respectively:</p>
+<div class="sourceCode" id="cb59"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb59-1"><a href="working-with-data-structures.html#cb59-1" tabindex="-1"></a>metadata.head()</span></code></pre></div>
+<pre><code>##       ModelID  PatientID  ...     OncotreePrimaryDisease       OncotreeLineage
+## 0  ACH-000001  PT-gj46wT  ...   Ovarian Epithelial Tumor  Ovary/Fallopian Tube
+## 1  ACH-000002  PT-5qa3uk  ...     Acute Myeloid Leukemia               Myeloid
+## 2  ACH-000003  PT-puKIyc  ...  Colorectal Adenocarcinoma                 Bowel
+## 3  ACH-000004  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 4  ACH-000005  PT-q4K2cp  ...     Acute Myeloid Leukemia               Myeloid
+## 
+## [5 rows x 30 columns]</code></pre>
+<div class="sourceCode" id="cb61"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb61-1"><a href="working-with-data-structures.html#cb61-1" tabindex="-1"></a>metadata.tail()</span></code></pre></div>
+<pre><code>##          ModelID  PatientID  ...          OncotreePrimaryDisease    OncotreeLineage
+## 1859  ACH-002968  PT-pjhrsc  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1860  ACH-002972  PT-dkXZB1  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1861  ACH-002979  PT-lyHTzo  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1862  ACH-002981  PT-Z9akXf  ...  Esophagogastric Adenocarcinoma  Esophagus/Stomach
+## 1863  ACH-003071  PT-LAGmLq  ...       Lung Neuroendocrine Tumor               Lung
+## 
+## [5 rows x 30 columns]</code></pre>
+<p>Both of these functions (without input arguments) are considered as <strong>methods</strong>: they are functions that does something with the Dataframe you are using it on. You should think about <code>metadata.head()</code> as a function that takes in <code>metadata</code> as an input. If we had another Dataframe called <code>my_data</code> and you want to use the same function, you will have to say <code>my_data.head()</code>.</p>
+</div>
+<div id="subsetting-dataframes" class="section level2 hasAnchor" number="2.7">
+<h2><span class="header-section-number">2.7</span> Subsetting Dataframes<a href="working-with-data-structures.html#subsetting-dataframes" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Perhaps the most important operation you will can do with Dataframes is subsetting them. There are two ways to do it. The first way is to subset by numerical indicies, exactly like how we did for lists.</p>
+<p>You will use the <a href="https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.iloc.html"><code>iloc</code></a> attribute and bracket operations, and you give two slices: one for the row, and one for the column.</p>
+<p>Let’s start with a small dataframe to see how it works before returning to <code>metadata</code>:</p>
+<div class="sourceCode" id="cb63"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb63-1"><a href="working-with-data-structures.html#cb63-1" tabindex="-1"></a>df <span class="op">=</span> pd.DataFrame(data<span class="op">=</span>{<span class="st">&#39;status&#39;</span>: [<span class="st">&quot;treated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;untreated&quot;</span>, <span class="st">&quot;discharged&quot;</span>, <span class="st">&quot;treated&quot;</span>],</span>
+<span id="cb63-2"><a href="working-with-data-structures.html#cb63-2" tabindex="-1"></a>                            <span class="st">&#39;age_case&#39;</span>: [<span class="dv">25</span>, <span class="dv">43</span>, <span class="dv">21</span>, <span class="dv">65</span>, <span class="dv">7</span>],</span>
+<span id="cb63-3"><a href="working-with-data-structures.html#cb63-3" tabindex="-1"></a>                            <span class="st">&#39;age_control&#39;</span>: [<span class="dv">49</span>, <span class="dv">20</span>, <span class="dv">32</span>, <span class="dv">25</span>, <span class="dv">32</span>]})</span>
+<span id="cb63-4"><a href="working-with-data-structures.html#cb63-4" tabindex="-1"></a>df</span></code></pre></div>
+<pre><code>##        status  age_case  age_control
+## 0     treated        25           49
+## 1   untreated        43           20
+## 2   untreated        21           32
+## 3  discharged        65           25
+## 4     treated         7           32</code></pre>
+<p>Here is how the dataframe looks like with the row and column index numbers:</p>
+<p><img src="images/pandas_subset_0.png" /></p>
+<p>Subset the first fourth rows, and the first two columns:</p>
+<p><img src="images/pandas%20subset_1.png" /></p>
+<p>Now, back to <code>metadata</code> dataframe:</p>
+<p>Subset the first 5 rows, and first two columns:</p>
+<div class="sourceCode" id="cb65"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb65-1"><a href="working-with-data-structures.html#cb65-1" tabindex="-1"></a>metadata.iloc[:<span class="dv">5</span>, :<span class="dv">2</span>]</span></code></pre></div>
+<pre><code>##       ModelID  PatientID
+## 0  ACH-000001  PT-gj46wT
+## 1  ACH-000002  PT-5qa3uk
+## 2  ACH-000003  PT-puKIyc
+## 3  ACH-000004  PT-q4K2cp
+## 4  ACH-000005  PT-q4K2cp</code></pre>
+<p>If we want a custom slice that is not sequential, we can use an integer list. Subset the last 5 rows, and the 1st and 10 and 21th column:</p>
+<div class="sourceCode" id="cb67"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb67-1"><a href="working-with-data-structures.html#cb67-1" tabindex="-1"></a>metadata.iloc[<span class="dv">5</span>:, [<span class="dv">1</span>, <span class="dv">10</span>, <span class="dv">21</span>]]</span></code></pre></div>
+<pre><code>##       PatientID GrowthPattern  WTSIMasterCellID
+## 5     PT-ej13Dz    Suspension            2167.0
+## 6     PT-NOXwpH      Adherent             569.0
+## 7     PT-fp8PeY      Adherent            1806.0
+## 8     PT-puKIyc      Adherent            2104.0
+## 9     PT-AR7W9o      Adherent               NaN
+## ...         ...           ...               ...
+## 1859  PT-pjhrsc      Organoid               NaN
+## 1860  PT-dkXZB1      Organoid               NaN
+## 1861  PT-lyHTzo      Organoid               NaN
+## 1862  PT-Z9akXf      Organoid               NaN
+## 1863  PT-LAGmLq    Suspension               NaN
+## 
+## [1859 rows x 3 columns]</code></pre>
+<p>When we subset via numerical indicies, it’s called <strong>explicit subsetting</strong>. This is a great way to start thinking about subsetting your dataframes for analysis, but explicit subsetting can lead to some inconsistencies in the long run. For instance, suppose your collaborator added a new cell line to the metadata and changed the order of the column. Then your code to subset the last 5 rows and the columns will get you a different answer once the spreadsheet is changed.</p>
+<p>The second way is to subset by the column name and comparison operators, also known as <strong>implicit subsetting</strong>. This is much more robust in data analysis practice. You will learn about it next week!</p>
+</div>
+<div id="exercises-1" class="section level2 hasAnchor" number="2.8">
+<h2><span class="header-section-number">2.8</span> Exercises<a href="working-with-data-structures.html#exercises-1" class="anchor-section" aria-label="Anchor link to header"></a></h2>
+<p>Exercise for week 2 can be found <a href="https://colab.research.google.com/drive/1oIL3gKEZR2Lq16k6XY0HXIhjYl34pEjr?usp=sharing">here</a>.</p>
+
+</div>
+</div>
+<hr>
+<center> 
+  <div class="footer">
+      All illustrations <a href="https://creativecommons.org/licenses/by/4.0/">CC-BY. </a>
+      <br>
+      All other materials <a href= "https://creativecommons.org/licenses/by/4.0/"> CC-BY </a> unless noted otherwise.
+      <a href="https://hutchdatascience.org/" target="_blank"><img src="https://hutchdatascience.org/images/crazy-idea-wide.png" style="width: 80%; padding-left: 15px; padding-top: 8px;"</a>
+  </div>
+</center>
+            </section>
+
+          </div>
+        </div>
+      </div>
+<a href="intro-to-computing.html" class="navigation navigation-prev " aria-label="Previous page"><i class="fa fa-angle-left"></i></a>
+<a href="data-wrangling-part-1.html" class="navigation navigation-next " aria-label="Next page"><i class="fa fa-angle-right"></i></a>
+    </div>
+  </div>
+<script src="libs/gitbook-2.6.7/js/app.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/clipboard.min.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-search.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-sharing.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-fontsettings.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-bookdown.js"></script>
+<script src="libs/gitbook-2.6.7/js/jquery.highlight.js"></script>
+<script src="libs/gitbook-2.6.7/js/plugin-clipboard.js"></script>
+<script>
+gitbook.require(["gitbook"], function(gitbook) {
+gitbook.start({
+"sharing": {
+"github": false,
+"facebook": true,
+"twitter": true,
+"linkedin": false,
+"weibo": false,
+"instapaper": false,
+"vk": false,
+"whatsapp": false,
+"all": ["facebook", "twitter", "linkedin", "weibo", "instapaper"]
+},
+"fontsettings": {
+"theme": "white",
+"family": "sans",
+"size": 2
+},
+"edit": {
+"link": null,
+"text": null
+},
+"history": {
+"link": null,
+"text": null
+},
+"view": {
+"link": null,
+"text": null
+},
+"download": null,
+"search": {
+"engine": "fuse",
+"options": null
+},
+"toc": {
+"collapse": "section"
+}
+});
+});
+</script>
+
+</body>
+
+</html>
diff --git a/manuscript/1-Intro-to-Computing.md b/manuscript/1-Intro-to-Computing.md
new file mode 100644
index 0000000..46e4cf8
--- /dev/null
+++ b/manuscript/1-Intro-to-Computing.md
@@ -0,0 +1,7 @@
+# 1 Intro to Computing
+ 
+{type: iframe, title:1 Intro to Computing, width:800, height:600, poster:resources/chapt_screen_images/intro-to-computing.png}
+![](https://hutchdatascience.org/Intro_to_Python/intro-to-computing.html)
+ 
+
+ 
diff --git a/manuscript/2-Working-with-data-structures.md b/manuscript/2-Working-with-data-structures.md
new file mode 100644
index 0000000..bd51cf0
--- /dev/null
+++ b/manuscript/2-Working-with-data-structures.md
@@ -0,0 +1,7 @@
+# 2 Working with data structures
+ 
+{type: iframe, title:2 Working with data structures, width:800, height:600, poster:resources/chapt_screen_images/working-with-data-structures.png}
+![](https://hutchdatascience.org/Intro_to_Python/working-with-data-structures.html)
+ 
+
+ 
diff --git a/manuscript/3-Data-Wrangling,-Part-1.md b/manuscript/3-Data-Wrangling,-Part-1.md
new file mode 100644
index 0000000..bac04e4
--- /dev/null
+++ b/manuscript/3-Data-Wrangling,-Part-1.md
@@ -0,0 +1,7 @@
+# 3 Data Wrangling, Part 1
+ 
+{type: iframe, title:3 Data Wrangling, Part 1, width:800, height:600, poster:resources/chapt_screen_images/data-wrangling-part-1.png}
+![](https://hutchdatascience.org/Intro_to_Python/data-wrangling-part-1.html)
+ 
+
+ 
diff --git a/manuscript/4-Data-Wrangling,-Part-2.md b/manuscript/4-Data-Wrangling,-Part-2.md
new file mode 100644
index 0000000..8b5f020
--- /dev/null
+++ b/manuscript/4-Data-Wrangling,-Part-2.md
@@ -0,0 +1,7 @@
+# 4 Data Wrangling, Part 2
+ 
+{type: iframe, title:4 Data Wrangling, Part 2, width:800, height:600, poster:resources/chapt_screen_images/data-wrangling-part-2.png}
+![](https://hutchdatascience.org/Intro_to_Python/data-wrangling-part-2.html)
+ 
+
+ 
diff --git a/manuscript/5-Data-Visualization.md b/manuscript/5-Data-Visualization.md
new file mode 100644
index 0000000..ba4d554
--- /dev/null
+++ b/manuscript/5-Data-Visualization.md
@@ -0,0 +1,7 @@
+# 5 Data Visualization
+ 
+{type: iframe, title:5 Data Visualization, width:800, height:600, poster:resources/chapt_screen_images/data-visualization.png}
+![](https://hutchdatascience.org/Intro_to_Python/data-visualization.html)
+ 
+
+ 
diff --git a/manuscript/6-References.md b/manuscript/6-References.md
new file mode 100644
index 0000000..0b42ddc
--- /dev/null
+++ b/manuscript/6-References.md
@@ -0,0 +1,7 @@
+# 6 References
+ 
+{type: iframe, title:6 References, width:800, height:600, poster:resources/chapt_screen_images/references.png}
+![](https://hutchdatascience.org/Intro_to_Python/references.html)
+ 
+
+ 
diff --git a/manuscript/About-the-Authors.md b/manuscript/About-the-Authors.md
new file mode 100644
index 0000000..33bb63d
--- /dev/null
+++ b/manuscript/About-the-Authors.md
@@ -0,0 +1,7 @@
+# About the Authors
+ 
+{type: iframe, title:About the Authors, width:800, height:600, poster:resources/chapt_screen_images/about-the-authors.png}
+![](https://hutchdatascience.org/Intro_to_Python/about-the-authors.html)
+ 
+
+ 
diff --git a/manuscript/About-this-Course.md b/manuscript/About-this-Course.md
new file mode 100644
index 0000000..ab60358
--- /dev/null
+++ b/manuscript/About-this-Course.md
@@ -0,0 +1,7 @@
+# About this Course
+ 
+{type: iframe, title:About this Course, width:800, height:600, poster:resources/chapt_screen_images/index.png}
+![](https://hutchdatascience.org/Intro_to_Python/index.html)
+ 
+
+ 
diff --git a/manuscript/Book.txt b/manuscript/Book.txt
new file mode 100644
index 0000000..0537e51
--- /dev/null
+++ b/manuscript/Book.txt
@@ -0,0 +1,8 @@
+1-Intro-to-Computing.md
+2-Working-with-data-structures.md
+3-Data-Wrangling,-Part-1.md
+4-Data-Wrangling,-Part-2.md
+5-Data-Visualization.md
+6-References.md
+About-this-Course.md
+About-the-Authors.md
diff --git a/manuscript/resources/chapt_screen_images/about-the-authors.png b/manuscript/resources/chapt_screen_images/about-the-authors.png
new file mode 100644
index 0000000..f6ff1b5
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/about-the-authors.png differ
diff --git a/manuscript/resources/chapt_screen_images/data-visualization.png b/manuscript/resources/chapt_screen_images/data-visualization.png
new file mode 100644
index 0000000..69a9453
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/data-visualization.png differ
diff --git a/manuscript/resources/chapt_screen_images/data-wrangling-part-1.png b/manuscript/resources/chapt_screen_images/data-wrangling-part-1.png
new file mode 100644
index 0000000..7543182
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/data-wrangling-part-1.png differ
diff --git a/manuscript/resources/chapt_screen_images/data-wrangling-part-2.png b/manuscript/resources/chapt_screen_images/data-wrangling-part-2.png
new file mode 100644
index 0000000..e2a67e7
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/data-wrangling-part-2.png differ
diff --git a/manuscript/resources/chapt_screen_images/index.png b/manuscript/resources/chapt_screen_images/index.png
new file mode 100644
index 0000000..080abc1
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/index.png differ
diff --git a/manuscript/resources/chapt_screen_images/intro-to-computing.png b/manuscript/resources/chapt_screen_images/intro-to-computing.png
new file mode 100644
index 0000000..47e0677
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/intro-to-computing.png differ
diff --git a/manuscript/resources/chapt_screen_images/references.png b/manuscript/resources/chapt_screen_images/references.png
new file mode 100644
index 0000000..46c27b0
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/references.png differ
diff --git a/manuscript/resources/chapt_screen_images/working-with-data-structures.png b/manuscript/resources/chapt_screen_images/working-with-data-structures.png
new file mode 100644
index 0000000..126b6a8
Binary files /dev/null and b/manuscript/resources/chapt_screen_images/working-with-data-structures.png differ
diff --git a/resources/chapt_screen_images/about-the-authors.png b/resources/chapt_screen_images/about-the-authors.png
index 4d131e6..f6ff1b5 100644
Binary files a/resources/chapt_screen_images/about-the-authors.png and b/resources/chapt_screen_images/about-the-authors.png differ
diff --git a/resources/chapt_screen_images/chapter_urls.tsv b/resources/chapt_screen_images/chapter_urls.tsv
index 847fb4e..db350af 100644
--- a/resources/chapt_screen_images/chapter_urls.tsv
+++ b/resources/chapt_screen_images/chapter_urls.tsv
@@ -1,5 +1,9 @@
 url	chapt_title	img_path
 https://hutchdatascience.org/Intro_to_Python/index.html	About this Course	resources/chapt_screen_images/index.png
 https://hutchdatascience.org/Intro_to_Python/intro-to-computing.html	1 Intro to Computing	resources/chapt_screen_images/intro-to-computing.png
+https://hutchdatascience.org/Intro_to_Python/working-with-data-structures.html	2 Working with data structures	resources/chapt_screen_images/working-with-data-structures.png
+https://hutchdatascience.org/Intro_to_Python/data-wrangling-part-1.html	3 Data Wrangling, Part 1	resources/chapt_screen_images/data-wrangling-part-1.png
+https://hutchdatascience.org/Intro_to_Python/data-wrangling-part-2.html	4 Data Wrangling, Part 2	resources/chapt_screen_images/data-wrangling-part-2.png
+https://hutchdatascience.org/Intro_to_Python/data-visualization.html	5 Data Visualization	resources/chapt_screen_images/data-visualization.png
 https://hutchdatascience.org/Intro_to_Python/about-the-authors.html	About the Authors	resources/chapt_screen_images/about-the-authors.png
-https://hutchdatascience.org/Intro_to_Python/references.html	2 References	resources/chapt_screen_images/references.png
+https://hutchdatascience.org/Intro_to_Python/references.html	6 References	resources/chapt_screen_images/references.png
diff --git a/resources/chapt_screen_images/data-visualization.png b/resources/chapt_screen_images/data-visualization.png
new file mode 100644
index 0000000..69a9453
Binary files /dev/null and b/resources/chapt_screen_images/data-visualization.png differ
diff --git a/resources/chapt_screen_images/data-wrangling-part-1.png b/resources/chapt_screen_images/data-wrangling-part-1.png
new file mode 100644
index 0000000..7543182
Binary files /dev/null and b/resources/chapt_screen_images/data-wrangling-part-1.png differ
diff --git a/resources/chapt_screen_images/data-wrangling-part-2.png b/resources/chapt_screen_images/data-wrangling-part-2.png
new file mode 100644
index 0000000..e2a67e7
Binary files /dev/null and b/resources/chapt_screen_images/data-wrangling-part-2.png differ
diff --git a/resources/chapt_screen_images/index.png b/resources/chapt_screen_images/index.png
index 98f4567..080abc1 100644
Binary files a/resources/chapt_screen_images/index.png and b/resources/chapt_screen_images/index.png differ
diff --git a/resources/chapt_screen_images/intro-to-computing.png b/resources/chapt_screen_images/intro-to-computing.png
index 5d11049..47e0677 100644
Binary files a/resources/chapt_screen_images/intro-to-computing.png and b/resources/chapt_screen_images/intro-to-computing.png differ
diff --git a/resources/chapt_screen_images/references.png b/resources/chapt_screen_images/references.png
index b28dd87..46c27b0 100644
Binary files a/resources/chapt_screen_images/references.png and b/resources/chapt_screen_images/references.png differ
diff --git a/resources/chapt_screen_images/working-with-data-structures.png b/resources/chapt_screen_images/working-with-data-structures.png
new file mode 100644
index 0000000..126b6a8
Binary files /dev/null and b/resources/chapt_screen_images/working-with-data-structures.png differ