\n", + "\n", + "### Scatter plots\n", + "\n", + "Another option instead if a line plot is to use a scatter plot. For this option in `pyplot` use the command:\n", + "`plt.scatter(x,y)`\n", + "where `x` is the variable name of the list to be plotted on the x-axis, and `y` the variable name of the list to be plotted on the y-axis.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "a641c831-ce97-4bd8-9c8b-1169eb369b71", + "metadata": { + "slideshow": { + "slide_type": "" + }, + "tags": [ + "instructions" + ] + }, + "source": [ + "### Activity 2 Plotting a scatter graph\n", + "\n", + "\n", + "Table 2 contains the atomic radii of the third row p-block elements. hydrides. In the cell below complete the code to generate a sactter plot of this data, with group on the horizontal axis and atomic radii on the vertical axis.\n", + "\n", + "(*Hint:* it is not necessary to write the code from scratch. It is perfectly acceptable to copy the code from activity 1 and modify it to include the desired data.)\n", + "\n", + "
\n", + "\n", + "**Table 2** Atomic radii of third row p-block elements\n", + "\n", + "|Element |\tGroup\t| Atomic radii / pm |\n", + "|---|---|---|\n", + "|$\\text{Al}$|\t13\t|$125$|\n", + "|$\\text{Si}$|\t14\t|$118$|\n", + "|$\\text{P}$|\t15\t|$110$|\n", + "|$\\text{S}$|\t16\t|$104$|\n", + "|$\\text{Cl}$|\t17\t|$99$|\n", + "|$\\text{Ar}$|\t18\t|$98$|\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "89b96bae-bc5a-43f3-a966-9385d2ee8fbc", + "metadata": { + "slideshow": { + "slide_type": "" + }, + "tags": [ + "student" + ] + }, + "outputs": [], + "source": [ + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "group = \n", + "radii = \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "abe65330", + "metadata": { + "slideshow": { + "slide_type": "" + }, + "tags": [ + "solution" + ] + }, + "outputs": [], + "source": [ + "#Possible answer to Activity 2\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "group = [13,14,15,16,17,18]\n", + "radii = [125,118,110,104,99,98]\n", + "\n", + "plt.scatter(group,radii)\n", + "plt.xlabel(\"Group\")\n", + "plt.ylabel(\"Atomic radii / pm\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "a55c01ba-3804-4026-b278-faf4fdad8b78", + "metadata": {}, + "source": [ + "### Plotting multiple datasets\n", + "\n", + "To plot multiple sets of data on the same graph you include more than one of the\n", + "`plt.plot()` and/or the `plt.scatter()` commands.\n", + "\n", + "As multiple sets of data are to be plotted a legend should be included to indicate what each series represents. In the same `plt.plot()`/`plt.scatter()` code, after specifying the data to be plotted on the horizontal and vertical axes within the brackets, a comma should be added and then the option `label=(\"\")` used. A string can then be included between the speech marks to label the series. For example, to plot a scatter graph of the lists `x` and `y` with the series name `Series A` you would use the following command:\n", + "`plt.scatter(x,y, label=\"Series A\")`\n", + "\n", + "By default, the legend option is not turned on in `matplotlib`. To show the legends you need to include the line `plt.legend()`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "221e04f1", + "metadata": {}, + "source": [ + "### Activity 3 Plotting multiple datasets and including legends\n", + "\n", + "Complete the code in the cell below to generate a plot that contains the atomic radii of both the second and third row elements of the p-block. Remember to include a legend." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67345c3a", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "group = []\n", + "radii_2nd_period = []\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4b45182f", + "metadata": {}, + "outputs": [], + "source": [ + "#Possible answer to Activity 3\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "group = [13,14,15,16,17,18]\n", + "radii_2nd_period = [88,77,74,73,71,71]\n", + "radii_3rd_period = [125,118,110,104,99,98]\n", + "\n", + "plt.scatter(group,radii_2nd_period, label=\"2nd Period\")\n", + "plt.scatter(group,radii_3rd_period, label=\"3rd Period\")\n", + "plt.xlabel(\"Group\")\n", + "plt.ylabel(\"Atomic radii / pm\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "abef10e9", + "metadata": {}, + "source": [ + "## Further customisation options\n", + "\n", + "### Changing the colour on graphs\n", + "\n", + "There are many options within `matplotlib` to modify the appearance of a graph. For example, you may want to change the colour of lines or data points in your graph. This may not seem like an important aspect of coding, but this can be useful if you are creating multiple charts for reports or presentations, and you want consistency between them. \n", + "\n", + "`matplotlib` chooses default colours for plotting multiple datasets: the first `plt.plot()`/`plt.scatter()` routine will use the colour blue, the second will use orange, and so on.\n", + "\n", + "Changing the colour of a line or scatter plot in Python requires a small addition to the `plt.plot()` or `plt.scatter()` routines. This command is `color=\"\"`, where this is preceeded by a comma (similar to the syntax of `label=\"\"` command in the same routines). \n", + "\n", + "Note that the syntax in `matplotlib` uses the American spelling for ‘color’, instead of the British spelling.\n", + "\n", + "For example, if you wanted to change the colour of the scatter plots from blue to red in the completed code from activity 3 the entire line would appear\n", + "\n", + " plt.scatter(group,radii_2nd_period, label=\"2nd Period\", color=\"red\")\n", + "\n", + "This will however change the next plotted series to the default blue, so to fully customise you would need to state the colours for each series.\n", + "\n", + "Most of the common colours you could name are included in `matplotlib`. For a full list of the available colours you can check the [Matplotlib documentation]." + ] + }, + { + "cell_type": "markdown", + "id": "d4c09ef7", + "metadata": {}, + "source": [ + "### Gridlines\n", + "\n", + "There are instances where you may want to include gridlines on your plots. To include major grdilines you would use the command:\n", + "\n", + " plt.grid()\n", + "\n", + "If you wanted to include major gridlines and minor gridlines you would use the two following commands:\n", + "\n", + " plt.grid(which='both')\n", + " plt.minorticks_on()\n", + "\n", + "Where the second command turns on the minor ticks on both axis, and the 'both' in the plt.grid() command indicates both the minor and major gridlines. Further options can be found in the Matplotlib documentation (https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.grid.html)" + ] + }, + { + "cell_type": "markdown", + "id": "630154f7", + "metadata": {}, + "source": [ + "### Exporting plots as image files\n", + "\n", + "Once you have successfully created graphs with Python, you need to be able to save them for later use or to include them in other resources.\n", + "\n", + "`matplotlib` has a command for this:\n", + "\n", + " plt.savefig(\"file_name.png\")\n", + "\n", + "Here, `\"file_name.png\"` is the name you choose for the saved graph. It will be saved in a `.png` format.\n", + "\n", + "It is also possible to save a graph as a PDF file by changing the `.png` extension in the previous routine to `.pdf`.\n", + "\n", + "Note the `plt.savefig()` command must go *before* the `plt.show()` command. If you do not do this, then the saved image file will be blank. \n", + "\n", + "\n", + "\n", + "$$$$ SM - This is how it works in jupyterlab, not sure how it will work elsewhere $$$$" + ] + }, + { + "cell_type": "markdown", + "id": "d6857f12", + "metadata": {}, + "source": [ + "### Superscripts and subscripts on plots\n", + "\n", + "When displaying strings on plots generated using `matplotlib`, such as axis labels and legends, you may noticed that you have not been able to add formatting, this is because strings are displayed in plain text. This missing formatting is important when labelling scientific data, particularly for units or chemical formulas.\n", + "\n", + "As an example, consider the line of code to label the y axis with the concentration of some reaction species, [A], with the incorrect formatting for the units of concentration. \n", + "\n", + " plt.ylabel(\"[A]/mol dm-3\")\n", + " \n", + "To correctly display the ‘$-3$’ in superscript you can use the `pyplot` command:\n", + "\n", + " plt.ylabel(\"[A]/mol dm$^{-3}$\")\n", + " \n", + "In this command:\n", + "\n", + "* the first and second dollar signs, `$`, indicate the start and end of and the text you want to be formatted (the dollar signs will not be printed in the string)\n", + "* the curly braces, `{}`, contain the text you want to apply formatting to\n", + "* the caret, `^`, goes before the curly braces and is used to indicate the text within the braces should be a superscript.\n", + "\n", + "\n", + "Another common formatting option you will need is subscript. This is especially important when it comes to chemical formulas. Subscripts use a similar syntax to superscripts, but use an underscore `_` instead of the caret `^`.\n", + "\n", + "So if in the above example A was nitrogen dioxide you would use the following command:\n", + " \n", + " plt.ylabel(\"[NO$_{2}$]/mol dm$^{-3}$\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "0f09f12d", + "metadata": {}, + "source": [ + "## Todo\n", + "\n", + "Add more activities related to the options above" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c96f413a", + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lessons/files.md b/lessons/files.md new file mode 100644 index 0000000..78632af --- /dev/null +++ b/lessons/files.md @@ -0,0 +1,3 @@ +# Using Files + +This section will teach you how to read and write files using Python. diff --git a/lessons/files/elements.csv b/lessons/files/elements.csv new file mode 100644 index 0000000..7eafedb --- /dev/null +++ b/lessons/files/elements.csv @@ -0,0 +1,4 @@ +Name,Symbol,Number +Hydrogen,H,1 +Helium,He,2 +Lithium,Li,3 diff --git a/lessons/files/gas_const.txt b/lessons/files/gas_const.txt new file mode 100644 index 0000000..7afce3e --- /dev/null +++ b/lessons/files/gas_const.txt @@ -0,0 +1 @@ +The gas constant is: 8.314 J/K.mol \ No newline at end of file diff --git a/lessons/files/molecule.txt b/lessons/files/molecule.txt new file mode 100644 index 0000000..0e18691 --- /dev/null +++ b/lessons/files/molecule.txt @@ -0,0 +1 @@ +C2H6 diff --git a/lessons/files/reading_files.ipynb b/lessons/files/reading_files.ipynb new file mode 100644 index 0000000..7da41c0 --- /dev/null +++ b/lessons/files/reading_files.ipynb @@ -0,0 +1,291 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1767a58b", + "metadata": {}, + "source": [ + "# **Reading Files**\n", + "\n", + "## Prerequisites:\n", + "- Variables\n", + "- Iterables(?)\n", + "- Loops\n", + "\n", + "## Learning Outcomes:\n", + "- Open files using Python's built-in functions and extract their contents to variables\n", + "- Use the CSV module to read data from CSV files" + ] + }, + { + "cell_type": "markdown", + "id": "f4882898", + "metadata": {}, + "source": [ + "## Reading Files\n", + "\n", + "One of the common uses of Python in chemistry is to analyse large amounts of data. \n", + "This might be data gathered during an experiment that has been stored in a number of files, and Python has a number of built-in functions to read (and write) files. \n", + "In this section, we will explore how to read different types of files, including text files and CSV files, using Python's built-in capabilities.\n", + "\n", + "Let's start with a opening a simple text file and reading its contents:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ff6944a", + "metadata": {}, + "outputs": [], + "source": [ + "file = open('molecule.txt', 'r')\n", + "contents = file.read()\n", + "file.close()\n", + "print(contents)" + ] + }, + { + "cell_type": "markdown", + "id": "6d821f38", + "metadata": {}, + "source": [ + "After running the cell above, you should see the contents of the `molecule.txt` file in the cell output. \n", + "If you don't see the output, make sure that the file is in the same directory as this notebook. \n", + "You can also verify the output by checking the file's contents in a text editor.\n", + "\n", + "The first line of the code cell above opens the file `molecule.txt` using the `open()` function and saves it to a special file-reading Python *object* we have called `file`.\n", + "The `open()` function takes at least one argument which is either the file name (if in the same working directory) or the full filepath of the file.\n", + "It can also take a second argument to specify the mode in which the file is opened (e.g., `'r'` for reading, `'w'` for writing, etc.).\n", + "If you don't specify a mode, the file is opened in read mode by default.\n", + "\n", + "The second line of the code cell reads the entire contents of the file using the `read()` method of the file object and stores it in a variable called `contents`. \n", + "\n", + "The third line closes the file using the `close()` method and is considered good practice.\n", + "Otherwise we might leave it open, which can lead to various issues (e.g., file access errors).\n", + "\n", + "Finally, the last line prints the contents of the `contents` variable." + ] + }, + { + "cell_type": "markdown", + "id": "900f642e", + "metadata": {}, + "source": [ + "### Reading Files with `with`\n", + "We can also use the `with` statement to open files, which will automatically close the file for us when we are done with it.\n", + "This is a more \"Pythonic\" way to handle files and is generally recommended.\n", + "\n", + "Let's take a look at the same example using the `with` statement:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f63f3d19", + "metadata": {}, + "outputs": [], + "source": [ + "with open('molecule.txt', 'r') as file:\n", + " contents = file.read()\n", + "\n", + "print(contents)" + ] + }, + { + "cell_type": "markdown", + "id": "06bbb57c", + "metadata": {}, + "source": [ + "As before, we open the `molecule.txt` file and read its contents.\n", + "The difference is that we use the `with` statement to open the file, which automatically closes it when we are done with it (i.e., when we exit the `with` block).\n", + "\n", + "We now have a way to read files in Python, and use their contents as *variables* in our code." + ] + }, + { + "cell_type": "markdown", + "id": "8ec1d24a", + "metadata": {}, + "source": [ + "## Reading CSV Files\n", + "CSV (Comma Separated Values) files are a common format for storing tabular data, such as data from experiments or simulations.\n", + "Each line in a CSV file represents a row of data, and each value in the row is separated by a comma (you can easily verify this by opening up a CSV file in a text editor).\n", + "Python has a built-in module called `csv` that makes it easy to read (and write) CSV files.\n", + "\n", + "Let's take a look at how to read a CSV file using the `csv` module:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ca51d4d", + "metadata": {}, + "outputs": [], + "source": [ + "import csv\n", + "\n", + "with open('elements.csv') as file:\n", + " csv_reader = csv.reader(file)\n", + " for row in csv_reader:\n", + " print(row)" + ] + }, + { + "cell_type": "markdown", + "id": "7ae13696", + "metadata": {}, + "source": [ + "Here, we first import the built-in `csv` module to allow us to easily parse CSV files.\n", + "\n", + "Next we open the `elements.csv` file using the `with` statement as we have seen before.\n", + "Note that we are opening the file in read mode without needing to specify it explicitly.\n", + "\n", + "The `csv.reader()` function takes the file object as an argument and returns a CSV reader object that can be used to *iterate* over the rows in the CSV file.\n", + "\n", + "Finally, we use a `for` loop to iterate over the rows in the CSV file and print the contents of each row.\n", + "The csv_reader object allows us to access each row as a list of values, making it easy to work with the data." + ] + }, + { + "cell_type": "markdown", + "id": "760dcb9a", + "metadata": {}, + "source": [ + "## Exercises\n", + "\n", + "### Manipulate data\n", + "Use f-strings to print the contents of the `elements.csv` file in a more readable format.\n", + "Don't forget about the header row!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53a6fb7d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "633a2836", + "metadata": {}, + "source": [ + "Example answer (skipping the header entirely):\n", + "```python\n", + "import csv\n", + "\n", + "with open('elements.csv') as csvfile:\n", + " csv_reader = csv.reader(csvfile)\n", + " next(csv_reader) # Skip the header row\n", + " for row in csv_reader:\n", + " print(f\"Name: {row[0]}, Symbol: {row[1]}, Atomic Number: {row[2]}\")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "c67c1875", + "metadata": {}, + "source": [ + "### Using the file path\n", + "Try to open a file that is not in the same directory as this notebook and print its contents." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de2abab4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "3430cc73", + "metadata": {}, + "source": [ + "TODO: Example answer" + ] + }, + { + "cell_type": "markdown", + "id": "10c5379d", + "metadata": {}, + "source": [ + "### Loop through multiple files\n", + "TODO: Task involving looping through multiple files with a predictable filename (e.g. `001.csv`) and reading their contents." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "002dbb28", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "c1114d99", + "metadata": {}, + "source": [ + "TODO: Example answer" + ] + }, + { + "cell_type": "markdown", + "id": "619f5799", + "metadata": {}, + "source": [ + "## Debugging\n", + "The code below contains a bug and will not run.\n", + "See if you can fix it by reading the error message and using the information it provides." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "818250af", + "metadata": {}, + "outputs": [], + "source": [ + "with open('molecule.csv', 'r') as file:\n", + " text = file.read()\n", + "\n", + "print(text)" + ] + }, + { + "cell_type": "markdown", + "id": "f58d91db", + "metadata": {}, + "source": [ + "## TODO\n", + "- Discuss carriage returns and other special characters?\n", + "- Explain the distinction between text and binary files?" + ] + } + ], + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lessons/files/spectrum.dat b/lessons/files/spectrum.dat new file mode 100644 index 0000000..e0c2c25 --- /dev/null +++ b/lessons/files/spectrum.dat @@ -0,0 +1,9 @@ +nm abs +240 0.123 +250 0.132 +260 0.346 +270 0.563 +280 0.998 +290 0.377 +300 0.007 +310 0.002 diff --git a/lessons/files/writing_files.ipynb b/lessons/files/writing_files.ipynb new file mode 100644 index 0000000..1ce922f --- /dev/null +++ b/lessons/files/writing_files.ipynb @@ -0,0 +1,257 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "R-GtgLtZw1hH" + }, + "source": [ + "# **Writing files**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yjL3LTCFJXwl" + }, + "source": [ + "## **Learning Outcomes**\n", + "\n", + "The learning outcomes are as follows:\n", + "\n", + "1. Saving data into a newly created file\n", + "2. Add additional data into an existing file." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hTDYb2QRyNeb" + }, + "source": [ + "## **Pre-requisites**\n", + "\n", + "Variables
\n", + "FOR loops
\n", + "Writing f-strings
\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xUUYv_pr1Sbt" + }, + "source": [ + "## **Writing files**\n", + "\n", + "It is often necesary to be able to save chemical data, images etc. that have been generated as a result of data processing etc., which is known as 'writing'. You can choose either to write your data to:\n", + "(i) a new file, or\n", + "(ii) alternatively add (aka append) to an existing file.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BVX99iEZ3Rc2" + }, + "source": [ + "## **Writing data to a new file**\n", + "\n", + "In Python, in order to write data to a new file, you must first create a file, ensuring the the file is writable.\n", + "\n", + "In order to create a file, you can use the command 'open'. Following this (in ( ) brackets) you need to supply the name of the file that you want to create, followed by a comma and then indicate that you wish to *write* to the new file (as opposed to e.g. read) by using the tag 'w'.\n", + "\n", + "A simple example of this is given below:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "JRvmRpz13Q0o" + }, + "outputs": [], + "source": [ + "file = open('gas_const.txt', 'w')\n", + "\n", + "R = 8.314\n", + "file.write(\"The gas constant is: \" + str(R) + \" J/K.mol\")\n", + "\n", + "file.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KI8esPi893AW" + }, + "source": [ + "We have defined and assigned a value to the variable, R, that is to be written to the file. R will be written to the file as a string. We have constructed the string \"The gas constant is: 8.314 J/K.mol\" which is then written to the file using the file.write command. Lastly the file is closed.\n", + "\n", + "Google Colab: This simple file has been saved in a temporary storage location. You can have a look at the file that's just been written by selecting the File icon on the left-hand side of the Colab page. Within the 'Content' file, you should be able to see the file. Click on the three vertical dots on the right-hand side of the file, download and open.\n", + "**NOTICE FOR EDITORS: we appreciate that we've written this for Google Colab - so we will need to re-write this section**" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JQCkCjKt9UI7" + }, + "source": [ + "The way in which data is written to a file depends on the type of data itself. So... FINISH" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uYsrtUqF_k_s" + }, + "source": [ + "## **Writing a simple structured file**\n", + "\n", + "XXXX\n", + "\n", + "In the example below, the ... FINISH" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VPqkYrd1zla5" + }, + "outputs": [], + "source": [ + "file = open('spectrum.dat', 'w')\n", + "\n", + "wavelength = [240, 250, 260, 270, 280, 290]\n", + "absorbance = [0.123, 0.132, 0.346, 0.563, 0.998, 0.377, 0.021]\n", + "file.write(f\"nm \\t abs \\n\")\n", + "for i in range(len(wavelength)):\n", + " file.write(f\"{wavelength[i]} \\t {absorbance[i]}\\n\")\n", + "\n", + "file.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YBO7aNknGp7b" + }, + "source": [ + "In the above example, the 'f' in the file.write commands... FINISH" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RscVg7DyHKVW" + }, + "source": [ + "## **Appending to an existing file**\n", + "\n", + "You can also write data to an existsing file. In the example below, we will append some more data to the spectrum data created above.\n", + "\n", + "... FINISH" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "xpAqJWu2_ss2" + }, + "outputs": [], + "source": [ + "file = open('spectrum.dat', 'a')\n", + "\n", + "wavelength = [300, 310]\n", + "absorbance = [0.007, 0.002]\n", + "\n", + "for i in range(len(wavelength)):\n", + " file.write(f\"{wavelength[i]} \\t {absorbance[i]}\\n\")\n", + "\n", + "file.close()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Kp8OJXO1_oMr" + }, + "source": [ + "## **User-defined save paths**\n", + "\n", + "Although a library is required for a file dialogue pop-up, ... FINISH ALSO NEED TO CREATE CODE FOR THIS." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aVs6rJBuJLiw" + }, + "source": [ + "## **Exercises**\n", + "\n", + "**Exercise 1**
\n", + "Take the day of the month in which you were born (e.g. this would be 10 is you were born on the 10th April), and create a file named 'element.txt' and write the name of the element corresponding to the atomic number matching this.
\n", + "\n", + "**Exercise 2**
\n", + "Determine the group that the element identified in Exercise 1 below to and append this information to your file.
\n", + "\n", + "**Exercise 3:**
\n", + "Three moles of an ideal gas are ontained within a frictionless piston at 298.15 K. Use Python to calculate the volume of the gas at the following four different pressures:
\n", + "1.00 kPa
\n", + "10.00 kPa
\n", + "50.00 kPa
\n", + "100.00 kPa
\n", + "and output the results in a file, formatted as two columns of numbers (to two d.p.), with the first column being pressure and the second being volume." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tOX5HbrsJR02" + }, + "source": [ + "## **Learning Outcomes**\n", + "\n", + "FINISH" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "authorship_tag": "ABX9TyOe2vlSb52narfb6tegF/97", + "provenance": [] + }, + "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.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/lessons/loops_functions/For_Loop_Lesson.ipynb b/lessons/loops_functions/For_Loop_Lesson.ipynb new file mode 100644 index 0000000..0306d38 --- /dev/null +++ b/lessons/loops_functions/For_Loop_Lesson.ipynb @@ -0,0 +1,387 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "UuDCTZ7LX9Jb" + }, + "source": [ + "# The `for` loop\n", + "\n", + "## Learning Outcomes\n", + "- TODO\n", + "- \n", + "\n", + "## Prerequisites:\n", + "- Variables\n", + "- Comparison\n", + "- `if` statements" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2VRPDborAVn1" + }, + "source": [ + "
The `for` loop
\n", + "\n", + "One area where you will see a real benefit of using programming in your work is when you need to repeat a task over and over again. For example maybe you need to process the same type of data file many times with different values. This can take a lot of time one by one but Python can really come to your rescue and save you hours. Plus all your lab colleagues will be beating a path to your door to ask for your help. You will soon become the lab data processing guru!
\n", + "\n", + "\n", + "One of the easiest way to perform this task is to use a 'for' loop.
\n", + "\n", + "Here is an example:
" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VSiGQd0PKsxD" + }, + "outputs": [], + "source": [ + "molecules = [\"H2\", \"H2O\", \"CH4\"]\n", + "\n", + "for mol in molecules:\n", + " print(mol)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hwu0INZoK5FO" + }, + "source": [ + "The cell above results in three strings printed despite having only used a single `print()` statement. Let's look at this closer.\n", + "\n", + "We begin by defining a list of strings:\n", + "```python\n", + "molecules = [\"H2\", \"H2O\", \"CH4\"]\n", + "```\n", + "\n", + "We then start a loop with the line:\n", + "```python\n", + "for mol in molecules:\n", + "```\n", + "- `for` indicates that we will begin a loop.\n", + "- `mol` is a new variable that we are currently defining.\n", + "- `in molecules` indicates that we want to do repeat the operations in the loop once per element in the list `molecules`.\n", + "- `:` signals the beginning of the loop.\n", + "\n", + "After this line of code, `print(mol)` prints the contents of the `mol` variable to the screen.\n", + "\n", + "Notice how `print(mol)` has some leading spaces (typed with the `Task 1: Understanding a Loop \n",
+ "\n",
+ " Take a look at this code block and answer the questions\n",
+ "\n",
+ ">``` Python\n",
+ ">\n",
+ ">gas_list = ['Nitrogen', 'Oxygen', 'Fluorine']\n",
+ ">for gas in gas_list:\n",
+ "> print(gas)\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "MULTIPLE CHOICE QUESTION\n",
+ "\n",
+ "- The loop will print the name of each gas on a separate line (correct)\n",
+ "- the loop will print one line with all the gas names\n",
+ "- The variable gas takes on each value of gas list in turn (correct)\n",
+ "- the variable gas_list changes each time around the loop"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Task 2: Understanding a Loop \n",
+ "\n",
+ "In the lab you are making methyl benzoate according using the scheme below. Five scientists repeat the reaction starting with 3 g of benzoic acid and get of 2.5 g, 2.7 g, 3.1 g, 1.6 g and 4 g of product.\n",
+ "\n",
+ "
\n",
+ "\n",
+ "Lets use your understanding of for loops to quickly work out the yields for each person.\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "product_mass_list = [2.5,2.7,3.1,1.6,4]\n",
+ "starting_mass = 3 # grams\n",
+ "theoretical_yield = (_______/_______)*136\n",
+ "for product_mass in product_mass_list:\n",
+ " percent_yield = (_________ / ___________) * 100\n",
+ " # the print statement uses the f-string syntax to format the output of the calculation\n",
+ " print(f\"Percent yield: {percent_yield:.0f}%\")\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "\n",
+ "Lets use your understanding of for loops to quickly work out the yields for each person.\n",
+ "Click here to see a possible solution to Task 2
\n", + "\n", + ">```Python\n", + ">product_mass_list = [2.5,2.7,3.1,1.6,4]\n", + ">starting_mass = 3 # grams\n", + ">theoretical_yield = (starting_mass/122)*136\n", + ">for product_mass in product_mass_list:\n", + "> percent_yield = (product_mass / theoretical_yield) * 100\n", + "> # the print statement uses the f-string syntax to format the output of the calculation\n", + "> print(f\"Percent yield: {percent_yield:.0f}%\")\n", + ">```\n", + "Task 3: Understanding a Loop \n",
+ "\n",
+ "You have a series of temperature measurements from your reaction in degrees C and you want to print them out in Kelvin. One of your colleagues writes some code but it doesn't seem to be working. Can you identify the problem and fix the code?\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Your colleagues code\n",
+ "\n",
+ "# The code below is not working. Can you fix it?\n",
+ "temperature_measurements = [27.3, 28.1, 26.9, 27.5, 28.0]\n",
+ "for temperature_C in temperature_measurements:\n",
+ " temperature_K = temperature_C + 273.15\n",
+ "print(f\"Temperature: {temperature_K}°C\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Click here to see a possible solution to Task 3
\n", + "\n", + "Remember that the items that you want to do each time you go around the for loop need to be indented. In the example the print statement is not indented and so is not executed each time, but only one the loop is finished. You can fix the code just by indenting the print statement with the tab key.\n", + ">```Python\n", + ">temperature_measurements = [27.3, 28.1, 26.9, 27.5, 28.0]\n", + ">for temperature_C in temperature_measurements:\n", + "> temperature_K = temperature_C + 273.15\n", + "> print(f\"Temperature: {temperature_K}°C\")\n", + ">```\n", + "\n", + "Task 4: Understanding a Loop \n",
+ "\n",
+ "Run the code below and answer the following questions to check your understanding\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "natural_amino_acids = [\"Alanine\", \"Arginine\", \"Asparagine\", \"Aspartic acid\", \"Cysteine\", \"Glutamic acid\", \"Glutamine\", \"Glycine\", \"Histidine\", \"Isoleucine\", \"Leucine\", \"Lysine\", \"Methionine\", \"Phenylalanine\", \"Proline\", \"Serine\", \"Threonine\", \"Tryptophan\", \"Tyrosine\", \"Valine\"]\n",
+ "for amino_acid in natural_amino_acids:\n",
+ " print(f\"Amino acid: {amino_acid}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "MULTIPLE CHOICE QUESTION\n",
+ "\n",
+ "- The discrete variable is amino acid (correct)\n",
+ "- The discrete variable is amino acids\n",
+ "- The iterator is amino_acid\n",
+ "- The iterator is amino_acids (correct)\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Task 5: Using loops \n",
+ "\n",
+ "When chemists want to store molecular structures in a computer they can store in an encoded way called SMILES strings. You don't need to understand what these mean but just to know that libraries that can handle chemical structure can read them. The code below will import the RDKit package and print the structure of benzoic acid. The code works by passing the SMILES string for benzoic acid to the function display_molecule that then draws it out. Check out the functions lesson if you want to understand more about functions, but for this lesson all you just need to follow the syntax below.\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from rdkit import Chem\n",
+ "\n",
+ "def display_molecule (smiles_string):\n",
+ " mol = Chem.MolFromSmiles(smiles_string)\n",
+ " img=Chem.Draw.MolToImage(mol)\n",
+ " display(img)\n",
+ "\n",
+ "# display the structure of benzoic acid\n",
+ "benzoic_acid_miles = \"C1=CC=C(C=C1)C(=O)O\"\n",
+ "display_molecule(benzoic_acid_miles)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Task 5 continued \n",
+ "Now you know how to print one molecule lets use your understanding of for loops to print lots of molecules. Here are a list of the smiles strings of some interesting molecules, Dolutegravir a very important anti-hiv drug, Atovaquone which treats malaria and paclitaxol that is an important \n",
+ "\n",
+ "\n",
+ "
"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "molecule_smiles = ['C[C@@H]1CCO[C@@H]2N1C(=O)C3=C(C(=O)C(=CN3C2)C(=O)NCC4=C(C=C(C=C4)F)F)O',\n",
+ "'C1CC(CCC1C2=CC=C(C=C2)Cl)C3=C(C4=CC=CC=C4C(=O)C3=O)O',\n",
+ "'CC1=C2[C@H](C(=O)[C@@]3([C@H](C[C@@H]4[C@]([C@H]3[C@@H]([C@@](C2(C)C)(C[C@@H]1OC(=O)[C@@H]([C@H](C5=CC=CC=C5)NC(=O)C6=CC=CC=C6)O)O)OC(=O)C7=CC=CC=C7)(CO4)OC(=O)C)O)C)OC(=O)C']\n",
+ "\n",
+ "for smiles in molecule_smiles:\n",
+ " display_molecule(smiles)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "\n",
+ "
\n",
+ "\n",
+ "Using the concepts above write a for loop that will draw the structrue of all 3 molecules. You need to:\n",
+ "- define a list of the smiles strings\n",
+ "- loop through the list and display each molecule using the display_molecule function\n",
+ "\n",
+ "- \n",
+ "
- C[C@@H]1CCO[C@@H]2N1C(=O)C3=C(C(=O)C(=CN3C2)C(=O)NCC4=C(C=C(C=C4)F)F)O\n", + "
- C1CC(CCC1C2=CC=C(C=C2)Cl)C3=C(C4=CC=CC=C4C(=O)C3=O)O\n", + "
- CC1=C2[C@H](C(=O)[C@@]3([C@H](C[C@@H]4[C@]([C@H]3[C@@H]([C@@](C2(C)C)(C[C@@H]1OC(=O)[C@@H]([C@H](C5=CC=CC=C5)NC(=O)C6=CC=CC=C6)O)O)OC(=O)C7=CC=CC=C7)(CO4)OC(=O)C)O)C)OC(=O)C\n", + "