Merge pull request #37 from aeturrell/resolve_issues

closes Issue on page /data-visualise.html #25 to Add contributor #36

Author: aeturrell

data-transform.ipynb

@@ -882,7 +882,7 @@
    "id": "dd91d87a",
    "metadata": {},
    "source": [
-    "Of course, this is quite tedious if you have lots of columns! There are methods that can help make this easier depending on your context. Perhaps you'd just liked to sort the columns in order? This can be achieved by combining `sorted()` and the `reindex()` command (which works for rows or columns) with `axis=1`, which means the second axis ie columns."
+    "Of course, this is quite tedious if you have lots of columns! There are methods that can help make this easier depending on your context. Perhaps you'd just liked to sort the columns in order? This can be achieved by combining `sorted()` and the `reindex()` command (which works for rows or columns) with `axis=1`, which means the second axis (i.e. columns)."
    ]
   },
   {

data-visualise.ipynb

@@ -50,7 +50,7 @@
    "source": [
     "We'll also need to have the **pandas** package installed—this package, which we'll be seeing a lot of, is for data. You can similarly install it by running `pip install pandas` on the command line.\n",
     "\n",
-    "Finally, we'll also need some data (you can't science with data). We'll be using the Palmer penguins dataset. Unusually, this can also be installed as a package—normally you would load data from a file, but these data are so popular for tutorials they've found their way into an installable package. Run `pip install palmerpenguins` to get these data."
+    "Finally, we'll also need some data (you can't science without data). We'll be using the Palmer penguins dataset. Unusually, this can also be installed as a package—normally you would load data from a file, but these data are so popular for tutorials they've found their way into an installable package. Run `pip install palmerpenguins` to get these data."
    ]
   },
   {
@@ -182,7 +182,7 @@
    "id": "574fe39f",
    "metadata": {
     "tags": [
-     "remove-cell"
+     "remove-input"
     ]
    },
    "outputs": [],
@@ -1069,9 +1069,10 @@
     "\n",
     "Start by carefully comparing the code that you're running to the code in the book: A misplaced character can make all the difference!\n",
     "Make sure that every `(` is matched with a `)` and every `\"` is paired with another `\"`. In  Visual Studio Code, you can get extensions that colour match brackets so you can easily see if you closed them or not.\n",
+    "\n",
     "Sometimes you'll run the code and nothing happens.\n",
     "\n",
-    "One common problem when creating **letsplot** graphics is to put the `+` in the wrong place: it has to come at the end of the line, not the start.\n",
+    "For those coming from the R statistical programming language, you may be concerned about getting your `+` in the wrong place. Have no fear, however, as in the syntax for **letsplot** the `+` can go at the start or the end of the line.\n",
     "\n",
     "\n",
     "If you're still stuck, try the help.\n",
@@ -1086,7 +1087,7 @@
    "id": "f33dc022",
    "metadata": {},
    "source": [
-    "# Summary\n",
+    "## Summary\n",
     "\n",
     "In this chapter, you've learned the basics of data visualisation with ggplot2.\n",
     "We started with the basic idea that underpins **letsplot**: a visualisation is a mapping from variables in your data to aesthetic properties like position, colour, size and shape.\n",

welcome.md

@@ -19,3 +19,5 @@ We thank the following contributors:
 - [durraniu](https://github.com/durraniu)
 - [zekiakyol](https://github.com/zekiakyol)
 - [yibenhuang](https://github.com/yibenhuang)
+- [crossxwill](https://github.com/crossxwill)
+- [udurraniAtPresage](https://github.com/udurraniAtPresage)

workflow-style.ipynb

@@ -58,7 +58,7 @@
     "- use consistent verbs for function names, don't use `get_score()` and `grab_results()` (instead use `get` for both)\n",
     "- variable names should be snake_case and all lowercase, eg `first_name`\n",
     " - class names should be CamelCase, eg `MyClass`\n",
-    "function names should be snake_case and all lowercase, eg `quick_sort()`\n",
+    " - function names should be snake_case and all lowercase, eg `quick_sort()`\n",
     " - constants should be snake_case and all uppercase, eg `PI = 3.14159`\n",
     " - modules should have short, snake_case names and all lowercase, eg `pandas`\n",
     " - single quotes and double quotes are equivalent so pick one and be consistent—most automatic formatters prefer `\"`"
@@ -142,6 +142,56 @@
     "    return result\n",
     "```\n",
     "\n",
+    "When using *method chaining* (something you can see in action in [](data-transform)) it's necessary to put the chain inside parentheses and it's good practice to use a new line for every method. The code snippet below gives an example of what good looks like:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f0f5bb37",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "\n",
+    "df = pd.DataFrame(\n",
+    "    data={\n",
+    "        \"col0\": [0, 0, 0, 0],\n",
+    "        \"col1\": [0, 0, 0, 0],\n",
+    "        \"col2\": [0, 0, 0, 0],\n",
+    "        \"col3\": [\"a\", \"b\", \"b\", \"a\"],\n",
+    "        \"col4\": [\"alpha\", \"gamma\", \"gamma\", \"gamma\"],\n",
+    "    },\n",
+    "    index=[\"row\" + str(i) for i in range(4)],\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# Chaining inside parentheses works\n",
+    "\n",
+    "results = df.groupby([\"col3\", \"col4\"]).agg({\"col1\": \"count\", \"col2\": \"mean\"})\n",
+    "\n",
+    "results"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d6f3bf8",
+   "metadata": {},
+   "source": [
+    "And this is what *not* to do:\n",
+    "\n",
+    "```python\n",
+    "results = df\n",
+    "    .groupby([\"col3\", \"col4\"]).agg({\"col1\": \"count\", \"col2\": \"mean\"})\n",
+    "\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d016d530",
+   "metadata": {},
+   "source": [
     "## Principles of Clean Code\n",
     "\n",
     "While automation can help apply style, it can't help you write *clean code*. Clean code is a set of rules and principles that helps to keep your code readable, maintainable, and extendable. Writing code is easy; writing clean code is hard! However, if you follow these principles, you won't go far wong.\n",
@@ -171,7 +221,7 @@
     "\n",
     "Relatedly, do not have a single function that tries to do everything. Functions should have limits too; they should do approximately one thing. If you're naming a function and you have to use 'and' in the name then it's probably worth splitting it into two functions.\n",
     "\n",
-    "Functions should have no 'side effects' either; that is, they shouldn't only take in value(s), and output value(s) via a return statement. They shouldn't modify global variables or make other changes.\n",
+    "Functions should have no 'side effects' either; that is, they should only take in value(s), and output value(s) via a return statement. They shouldn't modify global variables or make other changes.\n",
     "\n",
     "Another good rule of thumb is that each function shouldn't have lots of separate arguments.\n",
     "\n",
@@ -220,7 +270,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.10.13"
   },
   "toc-showtags": true
  },

workflow-writing-code.ipynb

@@ -11,7 +11,7 @@
     "\n",
     "There are different ways to write (and run) code that suit different needs. For example, for creating a reproducible pipeline of tasks or writing production-grade software, you might opt for a script——a file that is mostly code. But for sending instructions to a colleague or exploring a narrative, you might choose to write your code in a notebook because it can present text and code together more naturally than a script can.\n",
     "\n",
-    "We already met some ways to write and run code in the subsequent chapters. Here, we'll be a bit more systematic so that, by the end of the chapter, you'll be comfortable writing code in both scripts and notebooks. For advanced users, there's also information on how to write code with markdown, using markdown files that contain executable code chunks. Scripts and notebooks are by far the most popular ways to write code though.\n",
+    "We already met some ways to write and run code in the previous chapters. Here, we'll be a bit more systematic so that, by the end of the chapter, you'll be comfortable writing code in both scripts and notebooks. For advanced users, there's also information on how to write code with markdown, using markdown files that contain executable code chunks. Scripts and notebooks are by far the most popular ways to write code though.\n",
     "\n",
     "Let's start with some definitions.\n",
     "\n",
@@ -32,7 +32,7 @@
     "|------|----------------|---------------|---------------|---------------|\n",
     "| Script, eg `script.py`   |   'Run in interactive window' in an integrated development environment (IDE)         | Python installation + an IDE with Python support, eg Visual Studio Code. | Can be run all-in-one or step-by-step as needed. Very powerful tools available to aid coding in scripts. De facto standard for production-quality code. Can be imported by other scripts. Version control friendly. | Not very good if you want to have lots of text alongside code.\n",
     "| Jupyter Notebook, eg `notebook.ipynb`   | Open the file with Visual Studio Code.     |   Use Visual Studio Code and the VS Code Jupyter extension. | Code and text can alternate in the same document. Rich outputs of code can be integrated into document. Can export to PDF, HTML, and more, with control over whether code inputs/outputs are shown, and either exported directly or via **Quarto**. Can be run all-in-one or step-by-step as needed. | Fussy to use with version control. Code and text cannot be mixed in same 'cell'. Not easy to import in other code files.\n",
-    "| Markdown with executable code chunks using [**Quarto**](https://quarto.org/), eg `markdown_script.qmd` | To produce output, write in a mix of markdown and code blocks and then export with commands like `quarto render markdown_script.qmd --to html` on the command line or using the [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=quarto.quarto). Other output types available. | Installations of Python and Quarto, plus their dependencies. | Allows for true mixing of text and code. Can export to wide variety of other formats, such as PDF and HTML, with control over whether code inputs/outputs are shown. Version control friendly. | Must be run all-in-one so cannot see outputs of individual code-chunks as you go. Cannot be imported by other code files.\n",
+    "| Markdown with executable code chunks using [**Quarto**](https://quarto.org/), eg `markdown_script.qmd` | To produce output, write in a mix of markdown and code blocks and then export with commands like `quarto render markdown_script.qmd --to html` on the command line or using the [Visual Studio Code extension](https://marketplace.visualstudio.com/items?itemName=quarto.quarto). Other output types available. | Installations of Python and Quarto, plus their dependencies. | Allows for true mixing of text and code. Can export to wide variety of other formats, such as PDF and HTML, with control over whether code inputs/outputs are shown. Version control friendly. | Cannot be imported by other code files.\n",
     "\n",
     "Some of the options above make use of the command line, a way to issue text-based instructions to your computer. Remember, the command line (aka the terminal) can be accessed via the Terminal app on Mac, the Command Prompt app on Windows, or <kbd>ctrl</kbd> + <kbd>alt</kbd> + <kbd>t</kbd> on Linux. To open up the command line within Visual Studio Code, you can use the keyboard shortcut <kbd>⌃</kbd> + <kbd>\\`</kbd> (on Mac) or \n",
     "<kbd>ctrl</kbd> + <kbd>\\`</kbd> (Windows/Linux), or click \"View > Terminal\".\n",