diff --git a/data/iris.data b/data/iris.data index 9998c23..a395342 100644 --- a/data/iris.data +++ b/data/iris.data @@ -1,4 +1,4 @@ -septal_length,septal_width,petal_length,petal_width,species +sepal_length,sepal_width,petal_length,petal_width,species 5.1,3.5,1.4,0.2,Iris-setosa 4.9,3.0,1.4,0.2,Iris-setosa 4.7,3.2,1.3,0.2,Iris-setosa diff --git a/data/orfs.txt b/data/orfs.txt new file mode 100644 index 0000000..1059abf --- /dev/null +++ b/data/orfs.txt @@ -0,0 +1,8 @@ +>orf0 +ATGTACGAGACAACCATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAA +>orf1 +ATGTACGAGACAACCATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAACAGAGCTTCCCGTAA +>orf2 +ATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAA +>orf3 +ATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAACAGAGCTTCCCGTAA diff --git a/lessons/lesson_06.ipynb b/lessons/lesson_06.ipynb index 30bc85b..a00db9e 100644 --- a/lessons/lesson_06.ipynb +++ b/lessons/lesson_06.ipynb @@ -37,16 +37,18 @@ "metadata": {}, "source": [ "## Functions\n", + "\n", "- functions are blocks of code that can be referenced and easily reused\n", "- can utilize parameters (arguments)\n", - "- argument order matters, but can be circumvented by using specific argument names (kwargs = keyword arguments)\n", + "- argument order matters, but can be circumvented by using specific argument names (`**kwargs` = keyword arguments)\n", "- runs when called\n", "- functions handle variables isolated from the outside code (usually, **exceptions apply**)\n", "- can return results via `return`, which is optional\n", "- defined by the keyword `def`\n", - "- requires a name (same rules apply as for variables, i.e. no digits at the beginning or no spaces)\n", + "- require a name (same rules apply as for variables, i.e. no digits at the beginning and no spaces)\n", + "- never define a function name that overwrites a build-in function (e.g. `print`, `sum`, `len`)\n", "- can have defaults (defined after the list of arguments)\n", - "- optionally (but good practise), each function has a doc string describing the function's purpose commonly using triple quotes" + "- optionally (but good practice), each function has a doc string describing the function's purpose commonly using triple quotes\n" ] }, { @@ -166,6 +168,7 @@ "metadata": {}, "outputs": [], "source": [ + "# note: type hints are not enforced or checked from python, but often from code editors\n", "print(new_function([\"a\", \"b\"], \"a\"))" ] }, @@ -209,37 +212,6 @@ "print(res)" ] }, - { - "cell_type": "markdown", - "id": "6485cfde", - "metadata": {}, - "source": [ - "## Additional comments on functions\n", - "- there are a lot of build-in functions like `len()` in Python\n", - "- the complete list can be found here: https://docs.python.org/3/library/functions.html\n", - "- **never define a function name that overwrites a build-in function** (it will mess with your code in unpredictable ways)\n", - "- the same is true for all keywords like `def`, `for`, `in` etc. (though the interpreter will just report an error)\n", - "- the full list of keywords can be found here: https://docs.python.org/3/reference/lexical_analysis.html#keywords" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "92355eff", - "metadata": {}, - "outputs": [], - "source": [ - "# example overwriting a built in function\n", - "print(sum([1, 2, 3]))\n", - "\n", - "\n", - "def sum(a):\n", - " return a\n", - "\n", - "\n", - "print(sum([1, 2, 3]))" - ] - }, { "cell_type": "markdown", "id": "ec2e75fa", @@ -267,85 +239,35 @@ "print(multiply(**my_dict))" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "638ba311", - "metadata": {}, - "outputs": [], - "source": [ - "my_dict = {\"factor1\": 2, \"factor2\": 3, \"factor3\": 4}\n", - "print(multiply(**my_dict))" - ] - }, { "cell_type": "markdown", - "id": "b6b8f745", - "metadata": {}, - "source": [ - "## Global vs local variables\n", - "- variables defined within a function are local to that function and cannot be accessed outside of it\n", - "- variables defined outside of any function are global and can be accessed from anywhere in the code, including inside functions (but not modified unless declared as global within the function)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e839327d", + "id": "f28f70c9", "metadata": {}, - "outputs": [], "source": [ - "def function_l():\n", - " s = \"I love Minneapolis!\"\n", - " print(\"Var s inside local function:\", s, \"\\n\")\n", - "\n", - "\n", - "def function_g():\n", - " global s\n", - " s = \"I love Seattle!\"\n", - " print(\"Var s inside global function:\", s, \"\\n\")\n", + "## Handling files\n", "\n", + "- files are an important concept to store and access information\n", + "- to handle files, Python can read and write human-readable files (more or less) directly\n", + "- for more complex input files (i.e. compressed or binary data files like bam), external libraries are required\n", "\n", - "s = \"I love NYC!\"\n", - "print(\"Var s outside any function:\", s, \"\\n\")\n", + "
\n", "\n", - "function_l()\n", - "print(\"Var s outside local function:\", s, \"\\n\")\n", + "- to open and close a file automatically, we use the built-in function `open(filename, mode)` in combination with a `with` statement\n", + "- the `mode` argument defines how the file is handled, commonly used are:\n", "\n", - "function_g()\n", - "print(\"Var s outside global function:\", s)" + "| mode | meaning | comment |\n", + "| :--: | :-----: | :---------------------------------- |\n", + "| 'r' | read | default |\n", + "| 'w' | write | overwrites files |\n", + "| 'a' | append | adds to the end of an existing file |\n" ] }, { "cell_type": "markdown", - "id": "182e2169", + "id": "e25b0de2", "metadata": {}, "source": [ - "> Personal recommendation: avoid global variables, they can make your code very hard to debug and understand" - ] - }, - { - "cell_type": "markdown", - "id": "f28f70c9", - "metadata": {}, - "source": [ - "# Handling files\n", - "- files are an important concept to store and access information\n", - "- to handle files, Python can read and write humanly readable files (more or less) directly\n", - "- for more complex input files (i.e. compressed or binary data files like bam), external libraries are required\n", - "\n", - "
\n", - "\n", - "- to open a file, we use the built-in function `open(filename,mode)`, which creates an iterator by line over the file\n", - "- to close a file, we use the method `.close()`. This makes sure, that everything has been written to the file. \n", - "\n", - "| mode | meaning | comment |\n", - "| :---: | :---: | :--- |\n", - "| 'r' | read | default |\n", - "| 'w' | write | overwrites files |\n", - "| 'a' | append | adds to the end of an existing file |\n", - "\n", - "- closing a data stream too early (i.e. when writing) will **not** create an error, but will become a problem later on" + "- the basic, all-purpose function for reading files with automatic closing:" ] }, { @@ -355,76 +277,48 @@ "metadata": {}, "outputs": [], "source": [ - "infile = open(\"../data/seqs.fas\", \"r\")\n", - "for line in infile:\n", - " print(\n", - " repr(line)\n", - " ) # repr() shows the string as it is stored in memory, including special characters like \\n for newlines\n", - " print(line)\n", - "infile.close()" + "with open(\"../data/seqs.fas\", \"r\") as infile:\n", + " for line in infile:\n", + " print(line)" ] }, { - "cell_type": "code", - "execution_count": null, - "id": "c2b62fc1", + "cell_type": "markdown", + "id": "bce430f3", "metadata": {}, - "outputs": [], "source": [ - "outfile = open(\"../data/new_seqs.fas\", \"w\")\n", - "for e, seq in enumerate([\"aaaa\", \"cccc\", \"gggg\", \"tttt\"]):\n", - " outfile.write(f\">{e}\\n{seq}\\n\")\n", - "outfile.close()" + "- similar for writing files, but with mode 'w' or 'a':" ] }, { "cell_type": "code", "execution_count": null, - "id": "1c3f06fb", + "id": "c2b62fc1", "metadata": {}, "outputs": [], "source": [ - "infile = open(\"../data/new_seqs.fas\", \"r\")\n", - "for line in infile:\n", - " print(\n", - " line.strip()\n", - " ) # removes white spaces and line breaks on the right side, i.e. aaaa\\n -> aaaa\n", - "infile.close()" + "with open(\"../data/new_seqs.fas\", \"w\") as outfile:\n", + " for e, seq in enumerate([\"aaaa\", \"cccc\", \"gggg\", \"tttt\"]):\n", + " outfile.write(f\">{e}\\n{seq}\\n\")" ] }, { "cell_type": "markdown", - "id": "543d3fda", - "metadata": {}, - "source": [ - "- there are alternative semantic ways to access files\n", - "- syntax is `with as :` \n", - "- this implies a proper closing when leaving this code construct / finishing processing\n", - "- the keyword `as` function as an alias" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "62b4eb0a", + "id": "9274670b", "metadata": {}, - "outputs": [], "source": [ - "with open(\"../data/seqs.fas\", \"a\") as outfile:\n", - " for e, seq in enumerate(\n", - " [\"acgt\", \"tgca\"], start=4\n", - " ): # optional start parameter for enumerate, default is 0\n", - " outfile.write(f\">{e}\\n{seq}\\n\")" + "- as a sanity check, we import the written file again\n", + "- note the `.strip()` method which removes white space and line breaks on the right side" ] }, { "cell_type": "code", "execution_count": null, - "id": "c2adb46a", + "id": "1c3f06fb", "metadata": {}, "outputs": [], "source": [ - "with open(\"../data/seqs.fas\", \"r\") as infile:\n", + "with open(\"../data/new_seqs.fas\", \"r\") as infile:\n", " for line in infile:\n", " print(line.strip())" ] @@ -434,9 +328,11 @@ "id": "014e605c", "metadata": {}, "source": [ - "# Reading a whole file\n", + "## Reading a whole file\n", + "\n", "- it is possible to read a whole file with the method `.read()` from an open file stream without processing it line by line\n", - "- this might not be advisable in most situations, because it just fills up the memory" + "- this might not be advisable in some situations, because it just fills up the memory\n", + "- note how all line breaks are part of one and the same string\n" ] }, { @@ -460,11 +356,12 @@ "# Exercises\n", "\n", "## Functions\n", + "\n", "- write a function that serves as a calculator for the four basic operations (addition, subtraction, multiplication, division)\n", "- the function should take three arguments: the first number, the second number, and the operation as a string (i.e. \"add\" or \"+\")\n", "- the function should return the result of the operation\n", "- the function should handle division by zero gracefully (i.e. return \"undefined\" or something similar)\n", - "- the function should have a doc string explaining its purpose and usage (enclosed by three quotes `'''`)" + "- the function should have a doc string explaining its purpose and usage (enclosed by three quotes `'''`)\n" ] }, { @@ -484,7 +381,7 @@ "metadata": {}, "source": [ "- create a second function to test the calculator function with a few examples, including division by zero\n", - "- the test function should print the results of the tests in a readable format" + "- the test function should print the results of the tests in a readable format\n" ] }, { @@ -504,7 +401,7 @@ "source": [ "- create a new function that given a nucleotide sequence returns the reverse complement of the sequence, focus on the 4 standard nucleotides (A, T, C, G) and ignore any other characters (e.g. N or -)\n", "- use dictionaries for the conversion of the nucleotides\n", - "- the function should take a string as input and return a string as output" + "- the function should take a string as input and return a string as output\n" ] }, { @@ -545,9 +442,10 @@ "id": "2958315e", "metadata": {}, "source": [ - "## file handling\n", - "- create a function to create a new file and write the sequence from the previous exercise (ORFs) into it\n", - "- read the file and print its content to the console" + "## File handling\n", + "\n", + "- create a function that exports the sequence from the previous exercise (ORFs) into a new file\n", + "- read the file and print its content to the console\n" ] }, { @@ -570,7 +468,7 @@ "metadata": { "celltoolbar": "Slideshow", "kernelspec": { - "display_name": "Python 3", + "display_name": "default", "language": "python", "name": "python3" }, @@ -584,7 +482,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.3" + "version": "3.13.13" } }, "nbformat": 4, diff --git a/lessons/lesson_10.ipynb b/lessons/lesson_10.ipynb new file mode 100644 index 0000000..f327636 --- /dev/null +++ b/lessons/lesson_10.ipynb @@ -0,0 +1,879 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a60ff099", + "metadata": {}, + "source": [ + "# Lesson 10\n", + "\n", + "### In this lesson, we will learn about the following topics:\n", + "\n", + "- the `tidyverse` packages for efficient data manipulation in R \n", + "- the `ggplot2` package for data visualization \n", + "\n", + "### Recap of previous lesson\n", + "\n", + "- basic data types and functions in R\n", + "- language differences between R and Python\n" + ] + }, + { + "cell_type": "markdown", + "id": "09216b2a", + "metadata": {}, + "source": [ + "## The `tidyverse` packages for data science\n", + "\n", + "- the `tidyverse` meta package is a collection of R packages with a common philosopohy\n", + "- it includes packages for:\n", + " - data manipulation: `dplyr`, `tidyr`,\n", + " - input/output: `readr`\n", + " - string manipulation: `stringr`\n", + " - factor manipulation: `forcats`\n", + " - data visualization: `ggplot2`\n", + "\n", + "- all of them can be imported together with `library(tidyverse)`\n", + "- today we will **go through a complete data analysis cycle** from data import, to manipulation, to visualization\n", + "- more examples for tidyverse applications can be found on the [R for Data Science](https://r4ds.had.co.nz/) website\n" + ] + }, + { + "cell_type": "markdown", + "id": "9716547e", + "metadata": {}, + "source": [ + "### Reading data\n", + "\n", + "- the `readr` package which is contained in the `tidyverse` provides functions for reading tabular data (`csv`, `tsv`, `txt`)\n", + "- the `read_csv()`/`read_tsv()`/`read_delim()` functions are used to read comma-separated values (CSV), tab-separated values (TSV), and other delimited files, respectively\n", + "- they function similarly to their base R counterparts (`read.csv()`, ...) but are more user-friendly in many ways" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfbc1421", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "# import packages\n", + "library(tidyverse)\n", + "\n", + "# read external data set in comma-separated format\n", + "df <- read_csv(\"../data/iris.data\")\n", + "\n", + "# print total number of rows\n", + "nrow(df)\n", + "\n", + "# print first couple of rows\n", + "head(df)" + ] + }, + { + "cell_type": "markdown", + "id": "8f7ce2a8", + "metadata": {}, + "source": [ + "- note that we can see the column names and types of this data frame ('tibble')\n", + "- the `read_()` functions have many more options to help reading specially formatted tables\n" + ] + }, + { + "cell_type": "markdown", + "id": "cc40d832", + "metadata": {}, + "source": [ + "### Summarizing data frames\n", + "\n", + "- the `iris` data set contains measurements of 150 iris flowers from three different species\n", + "- if we want to get an overview of the data, we can use `head()` (above), but also `summary()` or `glimpse()`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d05db167", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "summary(df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "134ba06d", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "glimpse(df)" + ] + }, + { + "cell_type": "markdown", + "id": "b0425046", + "metadata": {}, + "source": [ + "### Data manipulation with `dplyr`\n", + "\n", + "- `dplyr` and `tidyr` are the two main packages for data manipulation in R\n", + "- `dplyr` provides functions for filtering, selecting, grouping, and summarizing data\n", + "- `tidyr` provides functions for reshaping data (covered in next section)\n", + "- we will also introduce the **pipe operator** (`%>%` or `|>`), which is commonly used to chain commands together\n", + "- with the pipe, **the left-hand side is passed automatically** as the first argument to the function on the right-hand side" + ] + }, + { + "cell_type": "markdown", + "id": "aa97a21a", + "metadata": {}, + "source": [ + "**Selecting rows and columns**\n", + "\n", + "- we can use the `select()` function to select columns\n", + "- we can use the `rename()` function to rename columns (`new = old` syntax)\n", + "- we can use the `filter()` function to filter rows we want to keep\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b83311e", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df %>%\n", + " select(species, sepal_length) %>%\n", + " rename(iris_name = species) %>%\n", + " filter(sepal_length > 7.0)\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "1f395824", + "metadata": {}, + "source": [ + "**Sorting by variables**\n", + "\n", + "- we can use the `arrange()` function to sort the data frame by one or more columns (first columns take precedence)\n", + "- the `desc()` function can be used to sort selected columns in descending order" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b68da74", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df %>%\n", + " arrange(species, desc(sepal_length)) %>%\n", + " head()" + ] + }, + { + "cell_type": "markdown", + "id": "e158b9f0", + "metadata": {}, + "source": [ + "- the `slice()` function in combination with `arrange()` is perfect to select the top N rows by a selected variable\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e1baa81", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "# select the first 6 rows with the smallest sepal width, all data\n", + "df %>%\n", + " arrange(sepal_width) %>%\n", + " slice(1:6)" + ] + }, + { + "cell_type": "markdown", + "id": "966cfb91", + "metadata": {}, + "source": [ + "- notably, all of the **tidyverse functions respect grouping** in data frames\n", + "- the following example will sort for each species separately and return the top 2 rows by sepal width" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b37b45e4", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "# select the first 2 rows with the largest sepal width for each species\n", + "df %>%\n", + " group_by(species) %>%\n", + " arrange(desc(sepal_width)) %>%\n", + " slice(1:2)\n" + ] + }, + { + "cell_type": "markdown", + "id": "4974753a", + "metadata": {}, + "source": [ + "**Creating and modifying columns**\n", + "\n", + "- arguably the most powerful function in `dplyr` is `mutate()`, which allows to change columns or create new ones\n", + "- it can be used to perform calculations on existing columns, or to create new columns based on conditions\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "86605eff", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df %>%\n", + " select(species, sepal_length, sepal_width) %>%\n", + " mutate(sepal_ratio = sepal_length / sepal_width) %>%\n", + " head()\n" + ] + }, + { + "cell_type": "markdown", + "id": "eb7dd1ca", + "metadata": {}, + "source": [ + "- the previous example performs each operation row-wise, but now we want to add a **group average**\n", + "- `mutate()` respects grouping, so **aggregating operations are performed per group**\n", + "- note that we can add several new columns with one `mutate()` call, including ones that depend on other new columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "665ea54a", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df %>%\n", + " select(species, sepal_length, sepal_width) %>%\n", + " group_by(species) %>%\n", + " mutate(\n", + " sepal_ratio = sepal_length / sepal_width,\n", + " mean_sepal_ratio = mean(sepal_ratio)) %>%\n", + " head()" + ] + }, + { + "cell_type": "markdown", + "id": "34c80f33", + "metadata": {}, + "source": [ + "**Summarizing data frames**\n", + "\n", + "- summarizing will collapse mutiple rows to a single row, broken down by the variables used in `group_by()`\n", + "- straightforward to do with `summarize()`, e.g. to calculate summary statistics for each group" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a4c365e0", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df %>%\n", + " group_by(species) %>%\n", + " summarize(\n", + " mean_sepal_length = mean(sepal_length),\n", + " mean_sepal_width = mean(sepal_width),\n", + " mean_petal_length = mean(petal_length),\n", + " mean_petal_width = mean(petal_width)\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "03468909", + "metadata": {}, + "source": [ + "### Rearranging data frames with `tidyr`\n", + "\n", + "- often we want to rearrange data from impractical **wide to long format**\n", + "- the `pivot_longer()` function is used to convert from wide to long format, while `pivot_wider()` does the opposite" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2f469cc", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "head(df) # before pivoting\n", + "\n", + "# note the 'cols' argument which specifies the columns we want to pivot\n", + "df_long <- df %>%\n", + " pivot_longer(\n", + " cols = -species,\n", + " names_to = \"variable\",\n", + " values_to = \"size_mm\"\n", + " )\n", + "\n", + "head(df_long) # after pivoting" + ] + }, + { + "cell_type": "markdown", + "id": "c7de6f60", + "metadata": {}, + "source": [ + "- to split a variable into multiple variables, we can use `separate()`, while `unite()` does the opposite\n", + "- in the example, we split the column `variable` into two columns, `leaf` and `measurement`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "039f8a5d", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_long <- df_long %>%\n", + " separate(variable, into = c(\"leaf\", \"measurement\"), sep = \"_\")\n", + "\n", + "head(df_long)" + ] + }, + { + "cell_type": "markdown", + "id": "1d447567", + "metadata": {}, + "source": [ + "## Data visualization with `ggplot2`\n", + "\n", + "- `ggplot2` is a powerful and flexible package for creating figures in R\n", + "- it is based on the \"Grammar of Graphics\", a philosophy for building plots in a layered approach\n", + "- the basic idea is to start with a blank canvas and add layers of data called *aesthetics* using different *geoms* (geometric objects)" + ] + }, + { + "cell_type": "markdown", + "id": "89d024ee", + "metadata": {}, + "source": [ + "- in the next example, we will use the reshaped `df_long` data frame we created previously\n", + "- practically, `ggplot2` figures are initiated using the `ggplot()` function with input data and *aesthetics* (mappings of input data variables to visual properties)\n", + "- new layers are added with the `+` operator" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "544f27c2", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "# select only length of sepals\n", + "df_long %>%\n", + " filter(leaf == \"sepal\", measurement == \"length\") %>%\n", + " ggplot(aes(x = species, y = size_mm, color = species)) +\n", + " geom_point(position = position_jitter(width = 0.2)) +\n", + " theme_classic()" + ] + }, + { + "cell_type": "markdown", + "id": "f2431121", + "metadata": {}, + "source": [ + "- plot all measurements by *faceting* (subsetting) two variables" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5ed9716", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_long %>%\n", + " ggplot(aes(x = species, y = size_mm, color = species)) +\n", + " geom_point(position = position_jitter(width = 0.2, height = 0)) +\n", + " facet_grid(leaf ~ measurement) +\n", + " theme_classic()" + ] + }, + { + "cell_type": "markdown", + "id": "ad8d4f41", + "metadata": {}, + "source": [ + "- we don't like the default theme, so define a new one based on the existing `theme_classic()`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29b73131", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "my_theme <- theme_classic(\n", + " base_size = 14,\n", + " base_line_size = 0.8,\n", + " base_rect_size = 0.8\n", + " ) +\n", + " theme(\n", + " panel.spacing = unit(7.5, \"mm\"),\n", + " panel.grid.major = element_line(linewidth = 0.6, linetype = \"solid\", colour = grey(0.8)),\n", + " strip.background = element_blank()\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bf8f7b21", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_long %>%\n", + " ggplot(aes(x = species, y = size_mm, color = species)) +\n", + " geom_point(position = position_jitter(width = 0.2, height = 0)) +\n", + " facet_grid(leaf ~ measurement) +\n", + " my_theme" + ] + }, + { + "cell_type": "markdown", + "id": "496ed59a", + "metadata": {}, + "source": [ + "- the following plots all use the same data but demonstrate the use of different `geom`s\n", + "\n", + "**Box plot**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "908139d4", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_long %>%\n", + " ggplot(aes(x = species, y = size_mm, color = species)) +\n", + " geom_boxplot() +\n", + " facet_grid(leaf ~ measurement) +\n", + " my_theme" + ] + }, + { + "cell_type": "markdown", + "id": "00302601", + "metadata": {}, + "source": [ + "**Violin plot**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9dc04ad9", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_long %>%\n", + " ggplot(aes(x = species, y = size_mm, color = species)) +\n", + " geom_violin() +\n", + " facet_grid(leaf ~ measurement) +\n", + " my_theme" + ] + }, + { + "cell_type": "markdown", + "id": "34d7b12b", + "metadata": {}, + "source": [ + "**Bar chart**" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0fd3533", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_long %>%\n", + " group_by(species, leaf, measurement) %>%\n", + " summarize(mean_size = mean(size_mm), .groups = \"drop\") %>%\n", + " ggplot(aes(x = species, y = mean_size, fill = species)) +\n", + " geom_col() +\n", + " facet_grid(leaf ~ measurement) +\n", + " my_theme" + ] + }, + { + "cell_type": "markdown", + "id": "2dc131ec", + "metadata": {}, + "source": [ + "**Heat map** (function of 3 variables)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bc1b1b2e", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "# heat maps require 3 variables: x, y, and z (the fill, numerical)\n", + "df_long %>%\n", + " group_by(measurement, species, leaf) %>%\n", + " mutate(sample = 1:n()) %>%\n", + " ggplot(aes(x = sample, y = paste(species, leaf), fill = size_mm)) +\n", + " geom_tile() +\n", + " scale_fill_gradient(low=\"white\", high=\"blue\") +\n", + " facet_grid( ~ measurement) +\n", + " my_theme" + ] + }, + { + "cell_type": "markdown", + "id": "c846e0c4", + "metadata": {}, + "source": [ + "**Histogram** (function of only 1 variable)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84d16b9b", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_long %>%\n", + " ggplot(aes(x = size_mm, color = species, fill = species)) +\n", + " geom_histogram(alpha = 0.5, color = NA) +\n", + " geom_density() +\n", + " facet_grid(leaf ~ measurement) +\n", + " my_theme" + ] + }, + { + "cell_type": "markdown", + "id": "71ed706c", + "metadata": {}, + "source": [ + "\n", + "## Exercises\n", + "\n", + "### Data manipulation\n", + "\n", + "- you get the following data frame `df_exercise` from a collaborator with data on bacterial growth rates\n", + "- how the data is generated is *not important* here" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f36fa47", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "df_exercise <- tibble(\n", + " species = rep(c(\"streptococcus\", \"staphylococcus\", \"bacillus\", \"listeria\"), each = 20),\n", + " strain = rep(c(\"slow_growing\", \"fast_growing\"), each = 10) %>% rep(4),\n", + " replicate = rep(1:5, 16),\n", + " growth_rate = as.numeric(\n", + " sapply(\n", + " c(0.4, 0.5, 0.75, 0.95, 0.3, 0.9, 1.2, 1.5),\n", + " function(x) do.call(rnorm, list(n = 10, mean = x, sd = x/3))\n", + " )\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "da4a8329", + "metadata": {}, + "source": [ + "- the first task is to get an overview using one of the summary functions (`head()`, ...)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3ddcbac", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "3c0ac3c4", + "metadata": {}, + "source": [ + "- for the next task, chain all commands together using the pipe operator `%>%`\n", + "- first, filter the data frame to keep only rows with the species `listeria`\n", + "- then rename the column `growth_rate` to `mu`\n", + "- just print the first rows of the result using `head()`, do not overwrite the original data frame" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce7fa155", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f3531068", + "metadata": {}, + "source": [ + "- group the data by `species`, sort by `growth_rate` in descending order (fastest first), and print the top 2 measurements" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "29bbcb00", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "cd417753", + "metadata": {}, + "source": [ + "- group the data by `species` and calculate the mean and standard deviation of the growth rate per group (use `summarize()`)\n", + "- add a new column `doubling_time`, which is calculated as `log(2) / mean_growth_rate`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5e49bfe5", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b8a3cb7a", + "metadata": {}, + "source": [ + "### Data visualization\n", + "\n", + "- for the same data frame, create a scatter plot of the growth rate (`y`-axis) by species (`x`-axis)\n", + "- you can optionally color the points by `species`, and use different symbols for `strain` (use `shape = strain` analogously to color)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2877321d", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "abbdec07", + "metadata": {}, + "source": [ + "- we are not sure if, for each species, slow growing strains are really growing different from fast growing strains\n", + "- create a box plot of the growth rate (`y`-axis) by strain (`x`-axis), and subset (facet) the plot by species" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7675e375", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f825056d", + "metadata": {}, + "source": [ + "## Recap and Conclusions\n", + "\n", + "- we have learned how to efficiently import, manipulate and plot data with a single metapackage, `tidyverse`\n", + "- many more data filtering and manipulation functions exist, that we have not covered but can be easily looked up:\n", + " - how to deal with empty values `NA` (remove, replace)\n", + " - bringing data into wide format, adding extra rows manually\n", + " - how R `factor`s can be used to control the order of all categorical data\n", + " - how to re-number rows, add ranks, cut and bin data, ..." + ] + }, + { + "cell_type": "markdown", + "id": "6f053207", + "metadata": {}, + "source": [ + "- for the `ggplot()` universe, various packages exist that are tuned towards the life science and extend plotting functionality\n", + " - `ggpubr` for plotting publication-ready (sub)figures\n", + " - `gggenomes` for plotting genomic features\n", + " - `ggcoverage` for plotting gene coverage data from e.g. `bam` files\n", + "\n", + "- for the import and manipulation of large-scale biological data, various bioconductor packages exist\n", + " - `rtracklayer`\n", + " - `GenomicRanges`\n", + " - `GenomicFeatures`\n", + " - ..." + ] + }, + { + "cell_type": "markdown", + "id": "89c3fa13", + "metadata": {}, + "source": [ + "## Thank you for following along!" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "R", + "language": "R", + "name": "ir" + }, + "language_info": { + "codemirror_mode": "r", + "file_extension": ".r", + "mimetype": "text/x-r-source", + "name": "R", + "pygments_lexer": "r", + "version": "4.5.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/solutions/solutions_06.ipynb b/solutions/solutions_06.ipynb index 75afffc..4ce1d8b 100644 --- a/solutions/solutions_06.ipynb +++ b/solutions/solutions_06.ipynb @@ -20,10 +20,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "b1fa44ec", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15\n" + ] + } + ], "source": [ "def my_calculator(num1, num2, operation):\n", " \"\"\"calculator performing the basic 4 math operations. Operator provided as string, e.g. 'add' or '+'.\"\"\"\n", @@ -49,15 +57,27 @@ "metadata": {}, "source": [ "- create a second function to test the calculator function with a few examples, including division by zero\n", - "- the test function should print the results of the tests in a readable format" + "- the test function should print the results of the tests in a readable format\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "c909207d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test for operation 'add' passed. 24 add 6 = 30\n", + "Test for operation '-' passed. 24 - 6 = 18\n", + "Test for operation 'multiply' passed. 24 multiply 6 = 144\n", + "Test for operation '/' passed. 24 / 6 = 4\n", + "Test for division by zero passed. 24 / 0 should return an error message.\n" + ] + } + ], "source": [ "def test_calculator():\n", " operations = [\"add\", \"-\", \"multiply\", \"/\"]\n", @@ -95,15 +115,26 @@ "source": [ "- create a new function that given a nucleotide sequence returns the reverse complement of the sequence, focus on the 4 standard nucleotides (A, T, C, G) and ignore any other characters (e.g. N or -)\n", "- use dictionaries for the conversion of the nucleotides\n", - "- the function should take a string as input and return a string as output" + "- the function should take a string as input and return a string as output\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "94675e33", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "'ACAGTgctgacgcatATCGAACGT'" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "sequence = \"ACGTTCGATatgcgtcagcACTGT\"\n", "\n", @@ -139,15 +170,23 @@ "metadata": {}, "source": [ "- in the sequence below are a few open reading frames (ORF), i.e. sequences that could potentially code for a protein (start with ATG and end with TAA)\n", - "- create a function that finds all ORFs in the sequence and returns them as a list" + "- create a function that finds all ORFs in the sequence and returns them as a list\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "9b767204", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['ATGTACGAGACAACCATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAA', 'ATGTACGAGACAACCATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAACAGAGCTTCCCGTAA', 'ATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAA', 'ATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAACAGAGCTTCCCGTAA']\n" + ] + } + ], "source": [ "seq = \"ATTGCTATCGTTCATGTACGAGACAACCATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAACAGAGCTTCCCGTAAACCGTATCCTCGCCC\"\n", "\n", @@ -182,16 +221,31 @@ "source": [ "### File handling\n", "\n", - "- create a function to create a new file and write the sequence from the previous exercise (ORFs) into it\n", + "- create a function that exports the sequence from the previous exercise (ORFs) into a new file\n", "- read the file and print its content to the console\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "2cabb303", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ">orf0\n", + "ATGTACGAGACAACCATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAA\n", + ">orf1\n", + "ATGTACGAGACAACCATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAACAGAGCTTCCCGTAA\n", + ">orf2\n", + "ATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAA\n", + ">orf3\n", + "ATGCCTACGATTGAGACGAGCGTTGAAGGAAACGAAAGTTAACAGAGCTTCCCGTAA\n" + ] + } + ], "source": [ "def write_orfs_to_file(seqs, outname=\"../data/orfs.txt\"):\n", " with open(outname, \"w\") as outfile:\n", @@ -214,7 +268,7 @@ "metadata": { "celltoolbar": "Slideshow", "kernelspec": { - "display_name": "Python 3", + "display_name": "default", "language": "python", "name": "python3" }, @@ -228,7 +282,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.14.3" + "version": "3.13.13" } }, "nbformat": 4, diff --git a/solutions/solutions_10.ipynb b/solutions/solutions_10.ipynb new file mode 100644 index 0000000..8ebec49 --- /dev/null +++ b/solutions/solutions_10.ipynb @@ -0,0 +1,518 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a60ff099", + "metadata": {}, + "source": [ + "# Lesson 10" + ] + }, + { + "cell_type": "markdown", + "id": "71ed706c", + "metadata": {}, + "source": [ + "\n", + "## Exercises\n", + "\n", + "### Data manipulation\n", + "\n", + "- you get the following data frame `df_exercise` from a collaborator with data on bacterial growth rates\n", + "- how the data is generated is *not important* here" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0f36fa47", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [], + "source": [ + "library(tidyverse)\n", + "\n", + "df_exercise <- tibble(\n", + " species = rep(c(\"streptococcus\", \"staphylococcus\", \"bacillus\", \"listeria\"), each = 20),\n", + " strain = rep(c(\"slow_growing\", \"fast_growing\"), each = 10) %>% rep(4),\n", + " replicate = rep(1:5, 16),\n", + " growth_rate = as.numeric(\n", + " sapply(\n", + " c(0.4, 0.5, 0.75, 0.95, 0.3, 0.9, 1.2, 1.5),\n", + " function(x) do.call(rnorm, list(n = 10, mean = x, sd = x/3))\n", + " )\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "da4a8329", + "metadata": {}, + "source": [ + "- the first task is to get an overview using one of the summary functions (`head()`, ...)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "f3ddcbac", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\n", + "
A tibble: 6 × 4
speciesstrainreplicategrowth_rate
<chr><chr><int><dbl>
streptococcusslow_growing10.5094191
streptococcusslow_growing20.6147542
streptococcusslow_growing30.2694271
streptococcusslow_growing40.4060076
streptococcusslow_growing50.6788068
streptococcusslow_growing10.4749519
\n" + ], + "text/latex": [ + "A tibble: 6 × 4\n", + "\\begin{tabular}{llll}\n", + " species & strain & replicate & growth\\_rate\\\\\n", + " & & & \\\\\n", + "\\hline\n", + "\t streptococcus & slow\\_growing & 1 & 0.5094191\\\\\n", + "\t streptococcus & slow\\_growing & 2 & 0.6147542\\\\\n", + "\t streptococcus & slow\\_growing & 3 & 0.2694271\\\\\n", + "\t streptococcus & slow\\_growing & 4 & 0.4060076\\\\\n", + "\t streptococcus & slow\\_growing & 5 & 0.6788068\\\\\n", + "\t streptococcus & slow\\_growing & 1 & 0.4749519\\\\\n", + "\\end{tabular}\n" + ], + "text/markdown": [ + "\n", + "A tibble: 6 × 4\n", + "\n", + "| species <chr> | strain <chr> | replicate <int> | growth_rate <dbl> |\n", + "|---|---|---|---|\n", + "| streptococcus | slow_growing | 1 | 0.5094191 |\n", + "| streptococcus | slow_growing | 2 | 0.6147542 |\n", + "| streptococcus | slow_growing | 3 | 0.2694271 |\n", + "| streptococcus | slow_growing | 4 | 0.4060076 |\n", + "| streptococcus | slow_growing | 5 | 0.6788068 |\n", + "| streptococcus | slow_growing | 1 | 0.4749519 |\n", + "\n" + ], + "text/plain": [ + " species strain replicate growth_rate\n", + "1 streptococcus slow_growing 1 0.5094191 \n", + "2 streptococcus slow_growing 2 0.6147542 \n", + "3 streptococcus slow_growing 3 0.2694271 \n", + "4 streptococcus slow_growing 4 0.4060076 \n", + "5 streptococcus slow_growing 5 0.6788068 \n", + "6 streptococcus slow_growing 1 0.4749519 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + " species strain replicate growth_rate \n", + " Length:80 Length:80 Min. :1 Min. :0.09928 \n", + " Class :character Class :character 1st Qu.:2 1st Qu.:0.47267 \n", + " Mode :character Mode :character Median :3 Median :0.73695 \n", + " Mean :3 Mean :0.83257 \n", + " 3rd Qu.:4 3rd Qu.:1.06682 \n", + " Max. :5 Max. :2.27901 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "head(df_exercise)\n", + "summary(df_exercise)" + ] + }, + { + "cell_type": "markdown", + "id": "3c0ac3c4", + "metadata": {}, + "source": [ + "- filter the data frame to keep only rows with the species `listera`\n", + "- rename the column `growth_rate` to `mu`\n", + "- print a couple of rows using `head()`, do not overwrite the original data frame" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "ce7fa155", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\n", + "
A tibble: 6 × 4
speciesstrainreplicatemu
<chr><chr><int><dbl>
listeriaslow_growing10.6941846
listeriaslow_growing20.9778354
listeriaslow_growing30.7937008
listeriaslow_growing40.8588253
listeriaslow_growing50.9323612
listeriaslow_growing11.4386164
\n" + ], + "text/latex": [ + "A tibble: 6 × 4\n", + "\\begin{tabular}{llll}\n", + " species & strain & replicate & mu\\\\\n", + " & & & \\\\\n", + "\\hline\n", + "\t listeria & slow\\_growing & 1 & 0.6941846\\\\\n", + "\t listeria & slow\\_growing & 2 & 0.9778354\\\\\n", + "\t listeria & slow\\_growing & 3 & 0.7937008\\\\\n", + "\t listeria & slow\\_growing & 4 & 0.8588253\\\\\n", + "\t listeria & slow\\_growing & 5 & 0.9323612\\\\\n", + "\t listeria & slow\\_growing & 1 & 1.4386164\\\\\n", + "\\end{tabular}\n" + ], + "text/markdown": [ + "\n", + "A tibble: 6 × 4\n", + "\n", + "| species <chr> | strain <chr> | replicate <int> | mu <dbl> |\n", + "|---|---|---|---|\n", + "| listeria | slow_growing | 1 | 0.6941846 |\n", + "| listeria | slow_growing | 2 | 0.9778354 |\n", + "| listeria | slow_growing | 3 | 0.7937008 |\n", + "| listeria | slow_growing | 4 | 0.8588253 |\n", + "| listeria | slow_growing | 5 | 0.9323612 |\n", + "| listeria | slow_growing | 1 | 1.4386164 |\n", + "\n" + ], + "text/plain": [ + " species strain replicate mu \n", + "1 listeria slow_growing 1 0.6941846\n", + "2 listeria slow_growing 2 0.9778354\n", + "3 listeria slow_growing 3 0.7937008\n", + "4 listeria slow_growing 4 0.8588253\n", + "5 listeria slow_growing 5 0.9323612\n", + "6 listeria slow_growing 1 1.4386164" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_exercise %>%\n", + " filter(species == \"listeria\") %>%\n", + " rename(mu = growth_rate) %>%\n", + " head()" + ] + }, + { + "cell_type": "markdown", + "id": "f3531068", + "metadata": {}, + "source": [ + "- group the data by `species`, sort by `growth_rate` in descending order (fastest first), and print the top 2 measurements" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "29bbcb00", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\n", + "
A grouped_df: 8 × 4
speciesstrainreplicategrowth_rate
<chr><chr><int><dbl>
bacillus fast_growing11.3730207
bacillus fast_growing11.3400134
listeria fast_growing52.2790084
listeria fast_growing31.9271994
staphylococcusfast_growing51.4963858
staphylococcusfast_growing31.4691279
streptococcus fast_growing20.7255741
streptococcus slow_growing50.6788068
\n" + ], + "text/latex": [ + "A grouped\\_df: 8 × 4\n", + "\\begin{tabular}{llll}\n", + " species & strain & replicate & growth\\_rate\\\\\n", + " & & & \\\\\n", + "\\hline\n", + "\t bacillus & fast\\_growing & 1 & 1.3730207\\\\\n", + "\t bacillus & fast\\_growing & 1 & 1.3400134\\\\\n", + "\t listeria & fast\\_growing & 5 & 2.2790084\\\\\n", + "\t listeria & fast\\_growing & 3 & 1.9271994\\\\\n", + "\t staphylococcus & fast\\_growing & 5 & 1.4963858\\\\\n", + "\t staphylococcus & fast\\_growing & 3 & 1.4691279\\\\\n", + "\t streptococcus & fast\\_growing & 2 & 0.7255741\\\\\n", + "\t streptococcus & slow\\_growing & 5 & 0.6788068\\\\\n", + "\\end{tabular}\n" + ], + "text/markdown": [ + "\n", + "A grouped_df: 8 × 4\n", + "\n", + "| species <chr> | strain <chr> | replicate <int> | growth_rate <dbl> |\n", + "|---|---|---|---|\n", + "| bacillus | fast_growing | 1 | 1.3730207 |\n", + "| bacillus | fast_growing | 1 | 1.3400134 |\n", + "| listeria | fast_growing | 5 | 2.2790084 |\n", + "| listeria | fast_growing | 3 | 1.9271994 |\n", + "| staphylococcus | fast_growing | 5 | 1.4963858 |\n", + "| staphylococcus | fast_growing | 3 | 1.4691279 |\n", + "| streptococcus | fast_growing | 2 | 0.7255741 |\n", + "| streptococcus | slow_growing | 5 | 0.6788068 |\n", + "\n" + ], + "text/plain": [ + " species strain replicate growth_rate\n", + "1 bacillus fast_growing 1 1.3730207 \n", + "2 bacillus fast_growing 1 1.3400134 \n", + "3 listeria fast_growing 5 2.2790084 \n", + "4 listeria fast_growing 3 1.9271994 \n", + "5 staphylococcus fast_growing 5 1.4963858 \n", + "6 staphylococcus fast_growing 3 1.4691279 \n", + "7 streptococcus fast_growing 2 0.7255741 \n", + "8 streptococcus slow_growing 5 0.6788068 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_exercise %>%\n", + " group_by(species) %>%\n", + " arrange(desc(growth_rate)) %>%\n", + " slice_head(n = 2)" + ] + }, + { + "cell_type": "markdown", + "id": "cd417753", + "metadata": {}, + "source": [ + "- group the data by `species` and calculate the mean and standard deviation of the growth rate per group (use `summarize()`)\n", + "- add a new column `doubling_time`, which is calculated as `log(2) / mean_growth_rate`" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5e49bfe5", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\n", + "\n", + "\t\n", + "\t\n", + "\t\n", + "\t\n", + "\n", + "
A tibble: 4 × 4
speciesmean_growth_ratesd_growth_ratedoubling_time
<chr><dbl><dbl><dbl>
bacillus 0.62445030.37773231.1100118
listeria 1.32592170.49057920.5227663
staphylococcus0.89217160.30492060.7769214
streptococcus 0.48773700.12831721.4211496
\n" + ], + "text/latex": [ + "A tibble: 4 × 4\n", + "\\begin{tabular}{llll}\n", + " species & mean\\_growth\\_rate & sd\\_growth\\_rate & doubling\\_time\\\\\n", + " & & & \\\\\n", + "\\hline\n", + "\t bacillus & 0.6244503 & 0.3777323 & 1.1100118\\\\\n", + "\t listeria & 1.3259217 & 0.4905792 & 0.5227663\\\\\n", + "\t staphylococcus & 0.8921716 & 0.3049206 & 0.7769214\\\\\n", + "\t streptococcus & 0.4877370 & 0.1283172 & 1.4211496\\\\\n", + "\\end{tabular}\n" + ], + "text/markdown": [ + "\n", + "A tibble: 4 × 4\n", + "\n", + "| species <chr> | mean_growth_rate <dbl> | sd_growth_rate <dbl> | doubling_time <dbl> |\n", + "|---|---|---|---|\n", + "| bacillus | 0.6244503 | 0.3777323 | 1.1100118 |\n", + "| listeria | 1.3259217 | 0.4905792 | 0.5227663 |\n", + "| staphylococcus | 0.8921716 | 0.3049206 | 0.7769214 |\n", + "| streptococcus | 0.4877370 | 0.1283172 | 1.4211496 |\n", + "\n" + ], + "text/plain": [ + " species mean_growth_rate sd_growth_rate doubling_time\n", + "1 bacillus 0.6244503 0.3777323 1.1100118 \n", + "2 listeria 1.3259217 0.4905792 0.5227663 \n", + "3 staphylococcus 0.8921716 0.3049206 0.7769214 \n", + "4 streptococcus 0.4877370 0.1283172 1.4211496 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_exercise %>%\n", + " group_by(species) %>%\n", + " summarize(\n", + " mean_growth_rate = mean(growth_rate),\n", + " sd_growth_rate = sd(growth_rate)\n", + " ) %>%\n", + " mutate(doubling_time = log(2) / mean_growth_rate)" + ] + }, + { + "cell_type": "markdown", + "id": "b8a3cb7a", + "metadata": {}, + "source": [ + "### Data visualization\n", + "\n", + "- for the same data frame, create a scatter plot of the growth rate (`y`-axis) by species (`x`-axis)\n", + "- you can optionally color the points by `species`, and use different symbols for `strain` (use `shape = strain` analogously to color)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "2877321d", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "plot without title" + ] + }, + "metadata": { + "image/png": { + "height": 420, + "width": 420 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "df_exercise %>%\n", + " ggplot(aes(x = species, y = growth_rate, color = species, shape = strain)) +\n", + " geom_point(position = position_jitter(width = 0.2))" + ] + }, + { + "cell_type": "markdown", + "id": "abbdec07", + "metadata": {}, + "source": [ + "- we are not sure if, for each species, slow growing strains are really growing different from fast growing strains\n", + "- create a box plot of the growth rate (`y`-axis) by strain (`x`-axis), and subset (facet) the plot by species" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "7675e375", + "metadata": { + "vscode": { + "languageId": "r" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "plot without title" + ] + }, + "metadata": { + "image/png": { + "height": 420, + "width": 420 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "df_exercise %>%\n", + " ggplot(aes(x = strain, y = growth_rate, color = species)) +\n", + " geom_boxplot() +\n", + " facet_wrap(~ species)" + ] + } + ], + "metadata": { + "celltoolbar": "Slideshow", + "kernelspec": { + "display_name": "R", + "language": "R", + "name": "ir" + }, + "language_info": { + "codemirror_mode": "r", + "file_extension": ".r", + "mimetype": "text/x-r-source", + "name": "R", + "pygments_lexer": "r", + "version": "4.5.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}