From e4ec849cbc0c83630e1cb2a2dfd26e7d95a15ae5 Mon Sep 17 00:00:00 2001 From: Andrew Straw Date: Fri, 29 Nov 2024 08:39:51 +0100 Subject: [PATCH] add source for exercise-07 --- exercises/source/exercise-07/1__classes.ipynb | 517 +++++++ .../source/exercise-07/2__pandas_intro.ipynb | 1269 +++++++++++++++++ .../source/exercise-07/3__plot_csv.ipynb | 69 + exercises/source/exercise-07/README.md | 17 + .../source/exercise-07/make_fake_data.ipynb | 118 ++ exercises/source/exercise-07/pcr_results.png | Bin 0 -> 33532 bytes exercises/source/exercise-07/pcr_sample_1.csv | 271 ++++ .../source/exercise-07/pcr_sample_1.csv.png | Bin 0 -> 33532 bytes exercises/source/exercise-07/plot_pcr_data.py | 10 + 9 files changed, 2271 insertions(+) create mode 100755 exercises/source/exercise-07/1__classes.ipynb create mode 100755 exercises/source/exercise-07/2__pandas_intro.ipynb create mode 100644 exercises/source/exercise-07/3__plot_csv.ipynb create mode 100644 exercises/source/exercise-07/README.md create mode 100644 exercises/source/exercise-07/make_fake_data.ipynb create mode 100644 exercises/source/exercise-07/pcr_results.png create mode 100644 exercises/source/exercise-07/pcr_sample_1.csv create mode 100644 exercises/source/exercise-07/pcr_sample_1.csv.png create mode 100644 exercises/source/exercise-07/plot_pcr_data.py diff --git a/exercises/source/exercise-07/1__classes.ipynb b/exercises/source/exercise-07/1__classes.ipynb new file mode 100755 index 0000000..33c09a6 --- /dev/null +++ b/exercises/source/exercise-07/1__classes.ipynb @@ -0,0 +1,517 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-df7302b349aba739", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "# Classes in Python\n", + "\n", + "First, let's consider some data in a plain Python dictionary:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-5eb4e7d87487b636", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "car1 = {\n", + " 'name': 'Fer',\n", + " 'worth': 60000,\n", + " 'type_': 'convertible',\n", + " 'color': 'red'\n", + "}\n", + "car2 = {\n", + " 'name': 'Jump',\n", + " 'worth': 10000,\n", + " 'type_': 'van',\n", + " 'color': 'blue'\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-b6fe8f994da7634c", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'Fer'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "car1['name']" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-2b0e27117c238bca", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Now, let's make a Python class which will hold this same kind of data:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-17b8022fd73e630c", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "class Car:\n", + " def __init__(self,name,worth,type_,color):\n", + " self.name = name\n", + " self.worth = worth\n", + " self.type_ = type_\n", + " self.color = color\n", + " def print_car(self):\n", + " print(\"%s is worth %d and is a %s %s.\"%(self.name, self.worth, self.color, self.type_))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-98bd27b61013b730", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "car1 = Car(\"Fer\",60000,\"convertible\",\"red\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-1055b5581d221586", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Takeaway message\n", + "\n", + "- The data in an instances of a class are conceptually very similar to python dicts with a few special features. One of these special features is methods. Another is that you access instance variables with with the `x_instance.name` syntax instead of `x_dict['name']` syntax." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-ce0b6c546e3ec2d5", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q1 creating an instance of a class\n", + "\n", + "We have a class defined for vehicles. Create two new vehicles (\"instances of the class\") with the variable names `car1` and `car2`. Set car1 to be a red convertible worth EUR 60,000.00 with a name of Fer, and car2 to be a blue van named Jump worth EUR 10,000.00." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-ae7291a16e80887f", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "class Vehicle:\n", + " def __init__(self, color, worth, name): \n", + " self.color = color\n", + " self.worth = worth\n", + " self.name = name\n", + " def get_description(self):\n", + " return 'name: {}, worth: {}, color: {}'.format(self.name, self.worth, self.color)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-3f2711d5634d8201", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "car1 = Vehicle('red', 60000, 'Fer')\n", + "car2 = Vehicle('blue', 10000, 'Jump')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-081ffcbe096c0760", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# This checks if your code works. Do not change it. It should run without error.\n", + "assert( car1.get_description()==\"name: Fer, worth: 60000, color: red\" )\n", + "assert( car2.get_description()==\"name: Jump, worth: 10000, color: blue\" )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-634909b4b67c316a", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q2 creating a class\n", + "\n", + "Create a class called `Pet`. The `__init__` function should take 3 arguments: `self`, `name`, and `sound`. The `name`, and `sound` arguments should be assigned to the instance variables `self.name` and `self.sound`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-6976ffa1c6d95602", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "class Pet:\n", + " def __init__(self, name, sound):\n", + " self.name = name\n", + " self.sound = sound" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-c49bb38441eca03a", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# This checks if your code works. Do not change it. It should run without error.\n", + "my_pet = Pet('Bob', 'talk')\n", + "assert(my_pet.name=='Bob')\n", + "assert(my_pet.sound=='talk')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-f34bb63b09eccd59", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q3 writing a method\n", + "\n", + "Now, create a new class called `NoisyPet`. The `__init__` function should be like in `Pet`. (It takes 3 arguments: `self`, `name`, and `sound`. The `name`, and `sound` arguments should be assigned to the instance variables `self.name` and `self.sound`.)\n", + "\n", + "`NoisyPet` should have an additional method called `make_noise` which takes zero additional arguments (of course `self` is required). The `make_noise` for a name of `\"cricket\"` and sound of `\"chirp\"`, this method should return a string like `\"My pet cricket makes a noise like chirp\"`. Thus, you will need to return a string you have created using string formatting." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-30ebdf29d3de2e41", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "class NoisyPet:\n", + " def __init__(self, name, sound):\n", + " self.name = name\n", + " self.sound = sound\n", + " def make_noise(self):\n", + " return \"My pet {} makes a noise like {}\".format(self.name, self.sound)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-232b938072cf100c", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# This checks if your code works. Do not change it. It should run without error.\n", + "assert(NoisyPet(\"cricket\", \"chirp\").make_noise()==\"My pet cricket makes a noise like chirp\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-ded0dd503cbcd3b7", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q4 using instances 1\n", + "\n", + "Now create a list named `my_pets` with 5 instances of the NoisyPet class given the following names and noises.\n", + "\n", + "| name | noise |\n", + "| --- | --- |\n", + "| Fido | slobber |\n", + "| Mr. Skinny Legs | (silent) |\n", + "| cricket | chirp |\n", + "| Adelheid | cackle |\n", + "| Bello | bark |" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-9e7de69ef49036d8", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "my_pets = [\n", + " NoisyPet(\"Fido\", \"slobber\"),\n", + " NoisyPet(\"Mr. Skinny Legs\", \"(silent)\"),\n", + " NoisyPet(\"cricket\", \"chirp\"),\n", + " NoisyPet(\"Adelheid\", \"cackle\"),\n", + " NoisyPet(\"Bello\", \"bark\"),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-ef3307b4ff8e4134", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# This checks if your code works. Do not change it. It should run without error.\n", + "assert(type(my_pets)==list)\n", + "assert(len(my_pets)==5)\n", + "for my_pet in my_pets:\n", + " assert(isinstance(my_pet,NoisyPet))\n", + " my_pet.make_noise()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-7f3ab5609b4c6d4b", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q5 using instances 2\n", + "\n", + "Now create a function list named `get_pet_name_length` which takes a single argument, which is an instance of the NoisyPet class. It should return the number of letters in the pet's name." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-4fb1927bd55587b9", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "def get_pet_name_length(pet):\n", + " return len(pet.name)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-adabc63962b7ba48", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# This checks if your code works. Do not change it. It should run without error.\n", + "assert(get_pet_name_length(NoisyPet(\"Bello\", \"bark\"))==5)\n", + "assert(get_pet_name_length(NoisyPet(\"cricket\", \"chirp\"))==7)" + ] + } + ], + "metadata": { + "celltoolbar": "Create Assignment", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/exercises/source/exercise-07/2__pandas_intro.ipynb b/exercises/source/exercise-07/2__pandas_intro.ipynb new file mode 100755 index 0000000..eff03f7 --- /dev/null +++ b/exercises/source/exercise-07/2__pandas_intro.ipynb @@ -0,0 +1,1269 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-4591728b0e94385d", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# You must run this cell, but you can ignore its contents.\n", + "\n", + "import hashlib\n", + "\n", + "def ads_hash(ty):\n", + " \"\"\"Return a unique string for input\"\"\"\n", + " ty_str = str(ty).encode()\n", + " m = hashlib.sha256()\n", + " m.update(ty_str)\n", + " return m.hexdigest()[:10]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-b2a0e9ec110c03e1", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-bfeafe88c3a0be38", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Let's get started by making a sample dataframe with fake data:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-710e679d69e83ae2", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
numbercolor
01blue
12blue
23red
3234red
42red
53blue
62blue
72red
81green
92yellow
\n", + "
" + ], + "text/plain": [ + " number color\n", + "0 1 blue\n", + "1 2 blue\n", + "2 3 red\n", + "3 234 red\n", + "4 2 red\n", + "5 3 blue\n", + "6 2 blue\n", + "7 2 red\n", + "8 1 green\n", + "9 2 yellow" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sample_df = pd.DataFrame({'number':[1,2,3,234,2,3,2,2,1,2], 'color':['blue','blue','red','red','red','blue','blue','red','green','yellow']})\n", + "display(sample_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-0320bf7579e7a5e0", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q1 Create a Series named `condition` which is true for all rows where the color is red" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-c57131439b7d2882", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "condition = sample_df[\"color\"]==\"red\"" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-c53eedea62c243e1", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash(condition)=='28612bf01a'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-ac32ae211af0e86d", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q2 Create a new `DataFrame` named `red_sample_df` which contains only the rows with red color from `sample_df`.\n", + "\n", + "Hint: use your `condition` Series from above." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-c4be64a1d42e707d", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "red_sample_df = sample_df[ condition ]" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-3c7eee81fa01c6e7", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash(red_sample_df)=='354bd7ec89'\n", + "assert ads_hash(sample_df)=='21692a4d62'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-98dc0525f2068315", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "Now let's use the DataFrame `.groupby()` method to find the mean value of `number` for each `color`. (Hint: this will be useful later in this exercise.)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-43c0e1a1816c47a2", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "blue 2.0\n", + "green 1.0\n", + "red 60.25\n", + "yellow 2.0\n" + ] + } + ], + "source": [ + "for color, gdf in sample_df.groupby('color'):\n", + " mean_number = gdf[\"number\"].mean()\n", + " print(f\"{color} {mean_number}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-9f757e6f5f690e81", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "# Using Pandas to work with real data\n", + "\n", + "\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-927793ccea2a12d7", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Get the CSV file and upload it to Jupyter\n", + "\n", + "* Go to https://datadryad.org/stash/dataset/doi:10.5061/dryad.vb06d3k and download the data by clicking \"Download Dataset\".\n", + " * Check that now have a file called `doi_10.5061_dryad.vb06d3k__v1.zip` about 99KB in size in your Downloads.\n", + " * Unzip this file, which should create:\n", + " - `spectra.csv`\n", + " - `data_onevalueperbee.csv`\n", + " - `data_visitationsequence.csv`\n", + " * We are going focus on the file `data_onevalueperbee.csv`. Upload this file to your Jupyter server using the `Upload` button in the file view. Upload it into the same directory as this `.ipynb` file. Alternatively, if you are running this on your own computer, you can copy this `.csv` file into the directory with your `.ipynb` file.\n", + "\n", + "## Look at the file\n", + "\n", + "As we have covered, CSV stands for \"Comma separated values\" and is one of the most widely used file formats for scientific data. CSV files are typically like tables, potentially with column names in the first line. The lines of the file are then rows of the table. Spreadsheet programs can open most CSV files, sometimes with a few settings being required to deal with various CSV dialects.\n", + "\n", + "Let's take a look at this CSV file. This is mostly a repitition of what we recently looked at. We open the CSV file read the first few lines." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-0964768c19f2b15e", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b'bee;nest;treatment;tstartforaging;logtstartforaging;maxminusstarttime;sumfeedingtime;logsumfeedingtime;numberofvisitations;sumdistcovered;meanvisitduration;revisitations;countyellow;countorange;countblue;visitblue;visitorange;visityellow;allcolorsvisited;averagedistance;meanspeed;sumflowersvisited;visitspatchA;visitspatchB;visitspatchC;patchesvisited;allpatchesvisited;visitsperpatchrounded\\r\\n'\n", + "b'201531004;3;control;815;2.911157609;1965;80;1.903089987;21;1287.688282;3.80952381;4;14;4;3;1;1;1;1;80.4805176;2.767026543;12;6;13;2;3;1;7\\r\\n'\n", + "b'201531005;3;control;108;2.033423755;;1;0;1;;1;0;1;0;0;0;0;1;0;;;1;1;0;0;1;0;0\\r\\n'\n", + "b'201531006;3;control;90;1.954242509;788;136;2.133538908;56;2787.280939;2.428571429;9;41;10;5;1;1;1;1;60.5930639;4.572772117;21;9;25;22;3;1;19\\r\\n'\n" + ] + } + ], + "source": [ + "# Open the file in Python. The variable `fd` will be assigned the open file object.\n", + "fd = open('data_onevalueperbee.csv', mode=\"rb\")\n", + "\n", + "# Iterate over the lines in the file, also creating an integer called `line_number` via the\n", + "# use of the `enumerate()` function.\n", + "for (line_number, line) in enumerate(fd.readlines()):\n", + " # Print each line.\n", + " print(line)\n", + " if line_number >= 3:\n", + " # Stop after a few lines\n", + " break\n", + "# Close the open file object.\n", + "fd.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-5dd558e28f33dab8", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "So, note that instead of a comma (`,`) separating the columns, we have a semicolon (`;`) instead. So we will need to use this when calling the Pandas `read_csv()` function. Thus, we must use the `sep=';'` keywoard argument. Also, this CSV file has some slightly unusual characters in it. From trial and error, I have learned that it must be opened with a `encoding='latin_1'` keyword argument to `read_csv()`.\n", + "\n", + "## Q3. Read the file `data_onevalueperbee.csv`? Into a dataframe named `df`.\n", + "\n", + "Hint: use the `read_csv` function not only with the filename as the required first positional argument, but also with the keyword arguments described above." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-107a3973d184c577", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [], + "source": [ + "df = pd.read_csv('data_onevalueperbee.csv', sep=';', encoding='latin_1')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-66fcba98183cb481", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash(df)=='15994f5b0e'" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-bdfe656f6d2cf933", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
beenesttreatmenttstartforaginglogtstartforagingmaxminusstarttimesumfeedingtimelogsumfeedingtimenumberofvisitationssumdistcovered...allcolorsvisitedaveragedistancemeanspeedsumflowersvisitedvisitspatchAvisitspatchBvisitspatchCpatchesvisitedallpatchesvisitedvisitsperpatchrounded
02015310043control8152.9111581965.0801.903090211287.688282...180.4805182.767027126132317
12015310053control1082.033424NaN10.0000001NaN...0NaNNaN1100100
22015310063control901.954243788.01362.133539562787.280939...160.5930644.57277221925223119
32015311013control10.000000320.0611.78533016578.355534...172.2944423.65135170151205
42015311023control00.000000656.02582.411620492845.622453...171.1405616.30713018424213116
\n", + "

5 rows × 28 columns

\n", + "
" + ], + "text/plain": [ + " bee nest treatment tstartforaging logtstartforaging \\\n", + "0 201531004 3 control 815 2.911158 \n", + "1 201531005 3 control 108 2.033424 \n", + "2 201531006 3 control 90 1.954243 \n", + "3 201531101 3 control 1 0.000000 \n", + "4 201531102 3 control 0 0.000000 \n", + "\n", + " maxminusstarttime sumfeedingtime logsumfeedingtime numberofvisitations \\\n", + "0 1965.0 80 1.903090 21 \n", + "1 NaN 1 0.000000 1 \n", + "2 788.0 136 2.133539 56 \n", + "3 320.0 61 1.785330 16 \n", + "4 656.0 258 2.411620 49 \n", + "\n", + " sumdistcovered ... allcolorsvisited averagedistance meanspeed \\\n", + "0 1287.688282 ... 1 80.480518 2.767027 \n", + "1 NaN ... 0 NaN NaN \n", + "2 2787.280939 ... 1 60.593064 4.572772 \n", + "3 578.355534 ... 1 72.294442 3.651351 \n", + "4 2845.622453 ... 1 71.140561 6.307130 \n", + "\n", + " sumflowersvisited visitspatchA visitspatchB visitspatchC \\\n", + "0 12 6 13 2 \n", + "1 1 1 0 0 \n", + "2 21 9 25 22 \n", + "3 7 0 15 1 \n", + "4 18 4 24 21 \n", + "\n", + " patchesvisited allpatchesvisited visitsperpatchrounded \n", + "0 3 1 7 \n", + "1 1 0 0 \n", + "2 3 1 19 \n", + "3 2 0 5 \n", + "4 3 1 16 \n", + "\n", + "[5 rows x 28 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Let's look at the first few lines of the file with the pandas DataFrame `.head()` method:\n", + "\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-85664fce05868fd1", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q4. How many rows of data are in the dataframe you read from the file `data_onevalueperbee.csv`? Put the answer in a variable `num_rows`.\n", + "\n", + "Hint: you can use `len(df)` to calculate the number of rows in the DataFrame `df`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-e10d9bb147d32ad5", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "159\n" + ] + } + ], + "source": [ + "# Type your answer here and then run this and the following cell.\n", + "num_rows = len(df)\n", + "print(num_rows)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-227f7cff2325cb9a", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash(num_rows)=='ff2ccb6ba4'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-6b133b10967bef7a", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q5. What are the unique values of the `nest` column?\n", + "\n", + "Put your answer in the variable `unique_nests`. Hint: use the `.unique()` method on the Series for the `nest` column." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-e0b36658308de988", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 3 4 6 8 9 10]\n" + ] + } + ], + "source": [ + "unique_nests = df['nest'].unique()\n", + "print(unique_nests)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-208034c33360f85d", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash(unique_nests)=='59e69ce283'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-7802496c83a4d50a", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q6. What are the unique values of the `treatment` column?\n", + "\n", + "Put your answer in the variable `unique_treatments`." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-7a258af7f499be42", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['control' 'imidacloprid']\n" + ] + } + ], + "source": [ + "unique_treatments = df['treatment'].unique()\n", + "print(unique_treatments)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-96c51bcd8e5a3ac3", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash(unique_treatments) == '670c49c25a'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's check which nests are in each treatment:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-2c145981d446e40d", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "control\n", + "[3 4 8]\n", + "\n", + "imidacloprid\n", + "[ 6 9 10]\n", + "\n" + ] + } + ], + "source": [ + "for treatment, gdf in df.groupby('treatment'):\n", + " print(treatment)\n", + " print(gdf['nest'].unique())\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-e5dbccbf3a349a88", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q7. Now make a `seaborn` `boxplot` of the time to start foraging (`tstartforaging` in the CSV file) on the `y` axis, `nest` number on the `x` axis, and with the color (`hue`) being the `treatment`. Save the plot to a file named `Figure2a.png`.\n", + "\n", + "Your plot should look like: \"\"\n", + "\n", + "Check the left panel of [Figure 2a](https://royalsocietypublishing.org/doi/10.1098/rspb.2018.0506#RSPB20180506F2) from the Lämsä et al. *Proc. Roy Soc B.* 2018 paper. Do you see any similarities or differences with your plot?\n", + "\n", + "Hint: import seaborn and call its `boxplot()` function with `data`, `x`, `y`, `hue` keyword arguments with values `df`, `nest`, `tstartforaging`, `treatment`." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-df2e372b53d245fd", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# Run this cell to import seaborn\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-208bdcdc93f0ff65", + "locked": false, + "points": 1, + "schema_version": 3, + "solution": true, + "task": false + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.boxplot(data=df,x='nest',y='tstartforaging',hue='treatment')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-c9c67275053aadd0", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q8. Now make a plot using a single line using seaborn's `boxplot` function which shows the duration of the foraging period on the y axis.\n", + "\n", + "This should be fairly similar to the second panel in [Figure 2a](https://royalsocietypublishing.org/doi/10.1098/rspb.2018.0506#RSPB20180506F2) from the Lämsä et al. Proc. Roy Soc B. 2018 paper.\n", + "\n", + "Hint: the duration of the foraging period is in the `'maxminusstarttime'` column." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-d6bb242d388543aa", + "locked": false, + "points": 1, + "schema_version": 3, + "solution": true, + "task": false + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Type your answer here\n", + "sns.boxplot(data=df,x='nest',y='maxminusstarttime',hue='treatment')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-b926439e7eb1c2b5", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q9. Make a dictionary called `mean_duration_of_foraging_by_treatment`. Fill this with items whose keys are treatment strings (`'control'` and `'imidacloprid'`) and whose values are the mean of all `'maxminusstarttime'` values for rows in which the `treatment` variable is the same as the key. \n", + "\n", + "Hint: use `groupby` to group on the `treatment` column and use the `.mean()` method on the `maxminusstarttime` Series within each group data frame. Store each mean as the value in your dictionary for the key." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-cdfad08c7777905d", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "control\n", + "1394.4603174603174\n", + "\n", + "imidacloprid\n", + "910.8152173913044\n", + "\n", + "{'control': 1394.4603174603174, 'imidacloprid': 910.8152173913044}\n" + ] + } + ], + "source": [ + "mean_duration_of_foraging_by_treatment = {}\n", + "\n", + "for treatment, gdf in df.groupby('treatment'):\n", + " print(treatment)\n", + " print(gdf['maxminusstarttime'].mean())\n", + " print()\n", + " mean_duration_of_foraging_by_treatment[treatment] = gdf['maxminusstarttime'].mean()\n", + " \n", + "print(mean_duration_of_foraging_by_treatment)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-ad0c60eabc04c1b7", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash([(k,int(round(v))) for (k,v) in mean_duration_of_foraging_by_treatment.items()]) == '14fe49a61a'" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-6718f15155ae17c2", + "locked": true, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "source": [ + "## Q10. Make a dictionary `num_unique_bees_per_nest` which has key-value pairs of nest number and the number of unique bees from that nest.\n", + "\n", + "Hint use `.groupby` on the `'nest'` column." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "nbgrader": { + "grade": false, + "grade_id": "cell-0df074ae6ba331e7", + "locked": false, + "schema_version": 3, + "solution": true, + "task": false + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{3: 8, 4: 23, 6: 37, 8: 34, 9: 33, 10: 24}\n" + ] + } + ], + "source": [ + "num_unique_bees_per_nest = {}\n", + "for nest, gdf in df.groupby('nest'):\n", + " num_unique_bees_per_nest[nest] = len(gdf['bee'].unique())\n", + "print(num_unique_bees_per_nest)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "nbgrader": { + "grade": true, + "grade_id": "cell-9fe3a1593835ed57", + "locked": true, + "points": 1, + "schema_version": 3, + "solution": false, + "task": false + } + }, + "outputs": [], + "source": [ + "# If this runs without error, it means the answer in your previous cell was correct.\n", + "assert ads_hash(num_unique_bees_per_nest)=='ddc47911c0'" + ] + } + ], + "metadata": { + "celltoolbar": "Create Assignment", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/exercises/source/exercise-07/3__plot_csv.ipynb b/exercises/source/exercise-07/3__plot_csv.ipynb new file mode 100644 index 0000000..689630f --- /dev/null +++ b/exercises/source/exercise-07/3__plot_csv.ipynb @@ -0,0 +1,69 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "0a7b652b-7846-464c-acf3-6629ba66a192", + "metadata": {}, + "source": [ + "# Create a standalone Python program\n", + "\n", + "The instructions for this exercise are in this Jupyter notebook, but to successfully complete the exercise, you need to write a plain Python `.py` file called `plot_pcr_data.py` that runs from the command line. Write your program so that when you run it like this:\n", + "\n", + " python plot_pcr_data.py pcr_sample_1.csv\n", + "\n", + "It will read load the CSV file named `pcr_sample_1.csv` and save a plot called `pcr_sample_1.csv.png`. This data file is the result of a [real-time PCR](https://en.wikipedia.org/wiki/Real-time_polymerase_chain_reaction) experiment in a 6 well plate. The plot should plot number of cycles on the X axis and fluorescence intensity on the Y axis. There should be a line for the data from each well in the experiment.\n", + "\n", + "Hints:\n", + "\n", + "- Remember that you can get the command-line arguments to a python program by importing the `sys` module and accessing the `sys.argv` variable, which is a list of strings. So the filename with the data is provided as a command-line argument to your python program.\n", + "- Read the CSV data from the provided filename using Pandas `read_csv()` function.\n", + "- Plot the results with [seaborn's `lineplot()`](https://seaborn.pydata.org/generated/seaborn.lineplot.html#seaborn.lineplot) function. The X value of the plot will by PCR cycle number and the Y value of the plot will be fluorescence intensity. To use one line per well, use the `hue` keyword argument.\n", + "- Save this figure (with matplotlib.pylot's `savefig()`) to a file with the name equal to the original file name with `.png` appended to it (e.g. for the above example with `pcr_sample_1.csv` as input, save the figure to `pcr_sample_1.csv.png`).\n", + "\n", + "Use the following imports block (and do not import anything else):\n", + "\n", + "```\n", + "import sys\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "```\n", + "\n", + "When you are done with your program `plot_pcr_data.py`, upload it to the directory for this exercise. I will run it with a new CSV data file from a different PCR experiments to check that it works.\n", + "\n", + "With `pcr_sample_1.csv`, your plot should look like this:\n", + "\n", + "![pcr_results.png](pcr_results.png)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79875b52-ccd1-4a13-bf1b-547a15466ebc", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/exercises/source/exercise-07/README.md b/exercises/source/exercise-07/README.md new file mode 100644 index 0000000..56589d4 --- /dev/null +++ b/exercises/source/exercise-07/README.md @@ -0,0 +1,17 @@ +# Notes: + +Release these files: + +1__classes.ipynb +2__pandas_intro.ipynb +3__plot_csv.ipynb +pcr_results.png +pcr_sample_1.csv + +Do not release these files: + +make_fake_data.ipynb - generate pcr_sample_1.csv +pcr_sample_1.csv.png - saved by example solution +plot_pcr_data.py - example solution +README.md - this file + diff --git a/exercises/source/exercise-07/make_fake_data.ipynb b/exercises/source/exercise-07/make_fake_data.ipynb new file mode 100644 index 0000000..16b683a --- /dev/null +++ b/exercises/source/exercise-07/make_fake_data.ipynb @@ -0,0 +1,118 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "a540c86a-3bed-4543-b952-342c796d7507", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "dc1ec4fb-4073-4d32-887f-e488ef0a9437", + "metadata": {}, + "outputs": [], + "source": [ + "t = np.arange(0,45)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "74ff2c1e-6c77-4aef-a26f-e86e5b1ce2d8", + "metadata": {}, + "outputs": [], + "source": [ + "# create signal\n", + "sig = -3*np.ones((6,45))\n", + "for rownum, start in enumerate([15,12,16,2,14,100]):\n", + " sig[rownum,start:] = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fdc289c2-b05f-4851-9fb2-01a7bda5dd5f", + "metadata": {}, + "outputs": [], + "source": [ + "# create measurement\n", + "meas = np.ones((6,45))\n", + "data2 = {'well':[], 'cycle': [], 'fluorescence': []}\n", + "data = {}\n", + "for row in range(6):\n", + " value = sig[row,0]\n", + " for col in range(45):\n", + " diff = sig[row,col] - value\n", + " value += 0.4*diff\n", + " meas[row,col] = value\n", + " data2['well'].append('well {}'.format(row+1))\n", + " data2['cycle'].append(col)\n", + " data2['fluorescence'].append(value)\n", + " data[f'well {row}'] = meas[row]\n", + "data[f'cycle'] = t\n", + "df = pd.DataFrame(data2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6e5b1731-6d98-41dd-8a38-f8c168aeaace", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.lineplot(data=df, x=\"cycle\", y=\"fluorescence\", hue=\"well\");\n", + "plt.savefig(\"pcr_results.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "841e114f-dd6d-4136-a093-8070a3069643", + "metadata": {}, + "outputs": [], + "source": [ + "df.to_csv('pcr_sample_1.csv', index=False)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/exercises/source/exercise-07/pcr_results.png b/exercises/source/exercise-07/pcr_results.png new file mode 100644 index 0000000000000000000000000000000000000000..e20d952e82861dc749053012f624b75da3565501 GIT binary patch literal 33532 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 literal 0 HcmV?d00001 diff --git a/exercises/source/exercise-07/pcr_sample_1.csv b/exercises/source/exercise-07/pcr_sample_1.csv new file mode 100644 index 0000000..dd22443 --- /dev/null +++ b/exercises/source/exercise-07/pcr_sample_1.csv @@ -0,0 +1,271 @@ +well,cycle,fluorescence +well 1,0,-3.0 +well 1,1,-3.0 +well 1,2,-3.0 +well 1,3,-3.0 +well 1,4,-3.0 +well 1,5,-3.0 +well 1,6,-3.0 +well 1,7,-3.0 +well 1,8,-3.0 +well 1,9,-3.0 +well 1,10,-3.0 +well 1,11,-3.0 +well 1,12,-3.0 +well 1,13,-3.0 +well 1,14,-3.0 +well 1,15,-1.7999999999999998 +well 1,16,-1.0799999999999998 +well 1,17,-0.6479999999999999 +well 1,18,-0.3887999999999999 +well 1,19,-0.23327999999999993 +well 1,20,-0.13996799999999995 +well 1,21,-0.08398079999999997 +well 1,22,-0.05038847999999998 +well 1,23,-0.030233087999999984 +well 1,24,-0.018139852799999988 +well 1,25,-0.010883911679999993 +well 1,26,-0.006530347007999996 +well 1,27,-0.0039182082047999976 +well 1,28,-0.0023509249228799984 +well 1,29,-0.001410554953727999 +well 1,30,-0.0008463329722367994 +well 1,31,-0.0005077997833420796 +well 1,32,-0.0003046798700052478 +well 1,33,-0.00018280792200314866 +well 1,34,-0.0001096847532018892 +well 1,35,-6.581085192113351e-05 +well 1,36,-3.948651115268011e-05 +well 1,37,-2.3691906691608062e-05 +well 1,38,-1.4215144014964837e-05 +well 1,39,-8.529086408978902e-06 +well 1,40,-5.117451845387341e-06 +well 1,41,-3.0704711072324042e-06 +well 1,42,-1.8422826643394425e-06 +well 1,43,-1.1053695986036654e-06 +well 1,44,-6.632217591621993e-07 +well 2,0,-3.0 +well 2,1,-3.0 +well 2,2,-3.0 +well 2,3,-3.0 +well 2,4,-3.0 +well 2,5,-3.0 +well 2,6,-3.0 +well 2,7,-3.0 +well 2,8,-3.0 +well 2,9,-3.0 +well 2,10,-3.0 +well 2,11,-3.0 +well 2,12,-1.7999999999999998 +well 2,13,-1.0799999999999998 +well 2,14,-0.6479999999999999 +well 2,15,-0.3887999999999999 +well 2,16,-0.23327999999999993 +well 2,17,-0.13996799999999995 +well 2,18,-0.08398079999999997 +well 2,19,-0.05038847999999998 +well 2,20,-0.030233087999999984 +well 2,21,-0.018139852799999988 +well 2,22,-0.010883911679999993 +well 2,23,-0.006530347007999996 +well 2,24,-0.0039182082047999976 +well 2,25,-0.0023509249228799984 +well 2,26,-0.001410554953727999 +well 2,27,-0.0008463329722367994 +well 2,28,-0.0005077997833420796 +well 2,29,-0.0003046798700052478 +well 2,30,-0.00018280792200314866 +well 2,31,-0.0001096847532018892 +well 2,32,-6.581085192113351e-05 +well 2,33,-3.948651115268011e-05 +well 2,34,-2.3691906691608062e-05 +well 2,35,-1.4215144014964837e-05 +well 2,36,-8.529086408978902e-06 +well 2,37,-5.117451845387341e-06 +well 2,38,-3.0704711072324042e-06 +well 2,39,-1.8422826643394425e-06 +well 2,40,-1.1053695986036654e-06 +well 2,41,-6.632217591621993e-07 +well 2,42,-3.9793305549731955e-07 +well 2,43,-2.3875983329839174e-07 +well 2,44,-1.4325589997903504e-07 +well 3,0,-3.0 +well 3,1,-3.0 +well 3,2,-3.0 +well 3,3,-3.0 +well 3,4,-3.0 +well 3,5,-3.0 +well 3,6,-3.0 +well 3,7,-3.0 +well 3,8,-3.0 +well 3,9,-3.0 +well 3,10,-3.0 +well 3,11,-3.0 +well 3,12,-3.0 +well 3,13,-3.0 +well 3,14,-3.0 +well 3,15,-3.0 +well 3,16,-1.7999999999999998 +well 3,17,-1.0799999999999998 +well 3,18,-0.6479999999999999 +well 3,19,-0.3887999999999999 +well 3,20,-0.23327999999999993 +well 3,21,-0.13996799999999995 +well 3,22,-0.08398079999999997 +well 3,23,-0.05038847999999998 +well 3,24,-0.030233087999999984 +well 3,25,-0.018139852799999988 +well 3,26,-0.010883911679999993 +well 3,27,-0.006530347007999996 +well 3,28,-0.0039182082047999976 +well 3,29,-0.0023509249228799984 +well 3,30,-0.001410554953727999 +well 3,31,-0.0008463329722367994 +well 3,32,-0.0005077997833420796 +well 3,33,-0.0003046798700052478 +well 3,34,-0.00018280792200314866 +well 3,35,-0.0001096847532018892 +well 3,36,-6.581085192113351e-05 +well 3,37,-3.948651115268011e-05 +well 3,38,-2.3691906691608062e-05 +well 3,39,-1.4215144014964837e-05 +well 3,40,-8.529086408978902e-06 +well 3,41,-5.117451845387341e-06 +well 3,42,-3.0704711072324042e-06 +well 3,43,-1.8422826643394425e-06 +well 3,44,-1.1053695986036654e-06 +well 4,0,-3.0 +well 4,1,-3.0 +well 4,2,-1.7999999999999998 +well 4,3,-1.0799999999999998 +well 4,4,-0.6479999999999999 +well 4,5,-0.3887999999999999 +well 4,6,-0.23327999999999993 +well 4,7,-0.13996799999999995 +well 4,8,-0.08398079999999997 +well 4,9,-0.05038847999999998 +well 4,10,-0.030233087999999984 +well 4,11,-0.018139852799999988 +well 4,12,-0.010883911679999993 +well 4,13,-0.006530347007999996 +well 4,14,-0.0039182082047999976 +well 4,15,-0.0023509249228799984 +well 4,16,-0.001410554953727999 +well 4,17,-0.0008463329722367994 +well 4,18,-0.0005077997833420796 +well 4,19,-0.0003046798700052478 +well 4,20,-0.00018280792200314866 +well 4,21,-0.0001096847532018892 +well 4,22,-6.581085192113351e-05 +well 4,23,-3.948651115268011e-05 +well 4,24,-2.3691906691608062e-05 +well 4,25,-1.4215144014964837e-05 +well 4,26,-8.529086408978902e-06 +well 4,27,-5.117451845387341e-06 +well 4,28,-3.0704711072324042e-06 +well 4,29,-1.8422826643394425e-06 +well 4,30,-1.1053695986036654e-06 +well 4,31,-6.632217591621993e-07 +well 4,32,-3.9793305549731955e-07 +well 4,33,-2.3875983329839174e-07 +well 4,34,-1.4325589997903504e-07 +well 4,35,-8.595353998742102e-08 +well 4,36,-5.157212399245261e-08 +well 4,37,-3.0943274395471566e-08 +well 4,38,-1.8565964637282937e-08 +well 4,39,-1.1139578782369761e-08 +well 4,40,-6.683747269421856e-09 +well 4,41,-4.0102483616531134e-09 +well 4,42,-2.4061490169918677e-09 +well 4,43,-1.4436894101951206e-09 +well 4,44,-8.662136461170723e-10 +well 5,0,-3.0 +well 5,1,-3.0 +well 5,2,-3.0 +well 5,3,-3.0 +well 5,4,-3.0 +well 5,5,-3.0 +well 5,6,-3.0 +well 5,7,-3.0 +well 5,8,-3.0 +well 5,9,-3.0 +well 5,10,-3.0 +well 5,11,-3.0 +well 5,12,-3.0 +well 5,13,-3.0 +well 5,14,-1.7999999999999998 +well 5,15,-1.0799999999999998 +well 5,16,-0.6479999999999999 +well 5,17,-0.3887999999999999 +well 5,18,-0.23327999999999993 +well 5,19,-0.13996799999999995 +well 5,20,-0.08398079999999997 +well 5,21,-0.05038847999999998 +well 5,22,-0.030233087999999984 +well 5,23,-0.018139852799999988 +well 5,24,-0.010883911679999993 +well 5,25,-0.006530347007999996 +well 5,26,-0.0039182082047999976 +well 5,27,-0.0023509249228799984 +well 5,28,-0.001410554953727999 +well 5,29,-0.0008463329722367994 +well 5,30,-0.0005077997833420796 +well 5,31,-0.0003046798700052478 +well 5,32,-0.00018280792200314866 +well 5,33,-0.0001096847532018892 +well 5,34,-6.581085192113351e-05 +well 5,35,-3.948651115268011e-05 +well 5,36,-2.3691906691608062e-05 +well 5,37,-1.4215144014964837e-05 +well 5,38,-8.529086408978902e-06 +well 5,39,-5.117451845387341e-06 +well 5,40,-3.0704711072324042e-06 +well 5,41,-1.8422826643394425e-06 +well 5,42,-1.1053695986036654e-06 +well 5,43,-6.632217591621993e-07 +well 5,44,-3.9793305549731955e-07 +well 6,0,-3.0 +well 6,1,-3.0 +well 6,2,-3.0 +well 6,3,-3.0 +well 6,4,-3.0 +well 6,5,-3.0 +well 6,6,-3.0 +well 6,7,-3.0 +well 6,8,-3.0 +well 6,9,-3.0 +well 6,10,-3.0 +well 6,11,-3.0 +well 6,12,-3.0 +well 6,13,-3.0 +well 6,14,-3.0 +well 6,15,-3.0 +well 6,16,-3.0 +well 6,17,-3.0 +well 6,18,-3.0 +well 6,19,-3.0 +well 6,20,-3.0 +well 6,21,-3.0 +well 6,22,-3.0 +well 6,23,-3.0 +well 6,24,-3.0 +well 6,25,-3.0 +well 6,26,-3.0 +well 6,27,-3.0 +well 6,28,-3.0 +well 6,29,-3.0 +well 6,30,-3.0 +well 6,31,-3.0 +well 6,32,-3.0 +well 6,33,-3.0 +well 6,34,-3.0 +well 6,35,-3.0 +well 6,36,-3.0 +well 6,37,-3.0 +well 6,38,-3.0 +well 6,39,-3.0 +well 6,40,-3.0 +well 6,41,-3.0 +well 6,42,-3.0 +well 6,43,-3.0 +well 6,44,-3.0 diff --git a/exercises/source/exercise-07/pcr_sample_1.csv.png b/exercises/source/exercise-07/pcr_sample_1.csv.png new file mode 100644 index 0000000000000000000000000000000000000000..c6c052a8ebe5366cf6477ce936d2782782c06771 GIT binary patch literal 33532 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 em(9WkK@Qgx3+sY`8VhugoZNCUX&y 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 literal 0 HcmV?d00001 diff --git a/exercises/source/exercise-07/plot_pcr_data.py b/exercises/source/exercise-07/plot_pcr_data.py new file mode 100644 index 0000000..126e649 --- /dev/null +++ b/exercises/source/exercise-07/plot_pcr_data.py @@ -0,0 +1,10 @@ +import sys +import matplotlib.pyplot as plt +import seaborn as sns +import pandas as pd + +csv_filename = sys.argv[1] +df = pd.read_csv(csv_filename) +sns.lineplot(data=df, x="cycle", y="fluorescence", hue="well") +png_filename = csv_filename + ".png" +plt.savefig(png_filename) \ No newline at end of file