fmt

Author: jph00

nbs/000_tour.ipynb

@@ -3,6 +3,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "4636a39a",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -14,27 +15,31 @@
   },
   {
    "cell_type": "markdown",
+   "id": "d99e49d2",
    "metadata": {},
    "source": [
     "# A tour of fastcore"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "8a5d405f",
    "metadata": {},
    "source": [
     "Here's a (somewhat) quick tour of a few higlights from fastcore."
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "50c03be8",
    "metadata": {},
    "source": [
     "### Documentation"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "7a5091fd",
    "metadata": {},
    "source": [
     "All fast.ai projects, including this one, are built with [nbdev](https://nbdev.fast.ai), which is a full literate programming environment built on Jupyter Notebooks. That means that every piece of documentation, including the page you're reading now, can be accessed as interactive Jupyter notebooks. In fact, you can even grab a link directly to a notebook running interactively on Google Colab - if you want to follow along with this tour, click the link below:"
@@ -43,6 +48,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "00336b56",
    "metadata": {},
    "outputs": [
     {
@@ -64,6 +70,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "8388646e",
    "metadata": {},
    "source": [
     "The full docs are available at [fastcore.fast.ai](https://fastcore.fast.ai). The code in the examples and in all fast.ai libraries follow the [fast.ai style guide](https://docs.fast.ai/dev/style.html). In order to support interactive programming, all fast.ai libraries are designed to allow for `import *` to be used safely, particular by ensuring that [`__all__`](https://riptutorial.com/python/example/2894/the---all---special-variable) is defined in all packages. In order to see where a function is from, just type it:"
@@ -72,6 +79,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "05687ae5",
    "metadata": {},
    "outputs": [
     {
@@ -91,6 +99,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "5c324091",
    "metadata": {},
    "source": [
     "For more details, including a link to the full documentation and source code, use `doc`, which pops up a window with this information:\n",
@@ -106,13 +115,15 @@
   },
   {
    "cell_type": "markdown",
+   "id": "34ec6c68",
    "metadata": {},
    "source": [
     "### Testing"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "96f09e79",
    "metadata": {},
    "source": [
     "fastcore's testing module is designed to work well with [nbdev](https://nbdev.fast.ai), which is a full literate programming environment built on Jupyter Notebooks. That means that your tests, docs, and code all live together in the same notebook. fastcore and nbdev's approach to testing starts with the premise that all your tests should pass. If one fails, no more tests in a notebook are run.\n",
@@ -123,6 +134,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "e194af33",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -131,6 +143,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "54fb6d99",
    "metadata": {},
    "source": [
     "That's an example from the docs for `coll_repr`. As you see, it's not showing you the output directly. Here's what that would look like:"
@@ -139,6 +152,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "e90b1325",
    "metadata": {},
    "outputs": [
     {
@@ -158,6 +172,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "a7cc0ef3",
    "metadata": {},
    "source": [
     "So, the test is actually showing you what the output looks like, because if the function call didn't return `'(#1000) [0,1,2,3,4...]'`, then the test would have failed.\n",
@@ -170,6 +185,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "9630506c",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -178,6 +194,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "a5da9f28",
    "metadata": {},
    "source": [
     "When a test fails, it prints out information about what was expected:\n",
@@ -201,6 +218,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "d3192bb1",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -209,6 +227,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "80ef89a5",
    "metadata": {},
    "source": [
     "You can even test that exceptions are raised:"
@@ -217,6 +236,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "4d653100",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -226,6 +246,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "5604458b",
    "metadata": {},
    "source": [
     "...and test that things are printed to stdout:"
@@ -234,6 +255,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "acfc8b62",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -242,13 +264,15 @@
   },
   {
    "cell_type": "markdown",
+   "id": "dd9f4fd9",
    "metadata": {},
    "source": [
     "### Foundations"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "fdc66d40",
    "metadata": {},
    "source": [
     "fast.ai is unusual in that we often use [mixins](https://en.wikipedia.org/wiki/Mixin) in our code. Mixins are widely used in many programming languages, such as Ruby, but not so much in Python. We use mixins to attach new behavior to existing libraries, or to allow modules to add new behavior to our own classes, such as in extension modules. One useful example of a mixin we define is `Path.ls`, which lists a directory and returns an `L` (an extended list class which we'll discuss shortly):"
@@ -257,6 +281,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "53cd9c94",
    "metadata": {},
    "outputs": [
     {
@@ -277,6 +302,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "ae689ed3",
    "metadata": {},
    "source": [
     "You can easily add you own mixins with the `patch` [decorator](https://realpython.com/primer-on-python-decorators/), which takes advantage of Python 3 [function annotations](https://www.python.org/dev/peps/pep-3107/#parameters) to say what class to patch:"
@@ -285,6 +311,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "1180fdcd",
    "metadata": {},
    "outputs": [
     {
@@ -307,6 +334,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "065b3f6f",
    "metadata": {},
    "source": [
     "We also use `**kwargs` frequently. In python `**kwargs` in a parameter like means \"*put any additional keyword arguments into a dict called `kwargs`*\". Normally, using `kwargs` makes an API quite difficult to work with, because it breaks things like tab-completion and popup lists of signatures. `utils` provides `use_kwargs` and `delegates` to avoid this problem. See our [detailed article on delegation](https://www.fast.ai/2019/08/06/delegation/) on this topic.\n",
@@ -317,6 +345,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "b242359e",
    "metadata": {},
    "outputs": [
     {
@@ -344,6 +373,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "8e379de8",
    "metadata": {},
    "source": [
     "Looking at that `ProductPage` example, it's rather verbose and duplicates a lot of attribute names, which can lead to bugs later if you change them only in one place. `fastcore` provides `store_attr` to simplify this common pattern. It also provides `basic_repr` to give simple objects a useful `repr`:"
@@ -352,6 +382,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "f7223633",
    "metadata": {},
    "outputs": [
     {
@@ -375,6 +406,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "820715ec",
    "metadata": {},
    "source": [
     "One of the most interesting `fastcore` functions is the `funcs_kwargs` decorator. This allows class behavior to be modified without sub-classing. This can allow folks that aren't familiar with object-oriented programming to customize your class more easily. Here's an example of a class that uses `funcs_kwargs`:"
@@ -383,6 +415,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "4a0e346e",
    "metadata": {},
    "outputs": [
     {
@@ -405,6 +438,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "cbe09f40",
    "metadata": {},
    "source": [
     "The `assert not kwargs` above is used to ensure that the user doesn't pass an unknown parameter (i.e one that's not in `_methods`). `fastai` uses `funcs_kwargs` in many places, for instance, you can customize any part of a `DataLoader` by passing your own methods.\n",
@@ -416,13 +450,15 @@
   },
   {
    "cell_type": "markdown",
+   "id": "df95dbde",
    "metadata": {},
    "source": [
     "### L"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "effd869a",
    "metadata": {},
    "source": [
     "Like most languages, Python allows for very concise syntax for some very common types, such as `list`, which can be constructed with `[1,2,3]`. Perl's designer Larry Wall explained the reasoning for this kind of syntax:\n",
@@ -435,6 +471,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "c2a76a2d",
    "metadata": {},
    "outputs": [
     {
@@ -454,6 +491,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "8c2adcc9",
    "metadata": {},
    "source": [
     "The first thing to notice is that an `L` object includes in its representation its number of elements; that's the `(#3)` in the output above. If there's more than 10 elements, it will automatically truncate the list:"
@@ -462,6 +500,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "5987aef4",
    "metadata": {},
    "outputs": [
     {
@@ -482,6 +521,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "461ab0e4",
    "metadata": {},
    "source": [
     "`L` contains many of the same indexing ideas that NumPy's `array` does, including indexing with a list of indexes, or a boolean mask list:"
@@ -490,6 +530,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "754c0de2",
    "metadata": {},
    "outputs": [
     {
@@ -509,6 +550,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "a1171e2d",
    "metadata": {},
    "source": [
     "It also contains other methods used in `array`, such as `L.argwhere`:"
@@ -517,6 +559,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "bbe0cd97",
    "metadata": {},
    "outputs": [
     {
@@ -536,6 +579,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "5192093b",
    "metadata": {},
    "source": [
     "As you can see from this example, `fastcore` also includes a number of features that make a functional style of programming easier, such as a full range of boolean functions (e.g `ge`, `gt`, etc) which give the same answer as the functions from Python's `operator` module if given two parameters, but return a [curried function](https://en.wikipedia.org/wiki/Currying) if given one parameter.\n",
@@ -546,6 +590,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "e00419dc",
    "metadata": {},
    "outputs": [
     {
@@ -566,21 +611,13 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "75ff9241",
    "metadata": {},
    "outputs": [],
    "source": []
   }
  ],
- "metadata": {
-  "jupytext": {
-   "split_at_heading": true
-  },
-  "kernelspec": {
-   "display_name": "python3",
-   "language": "python",
-   "name": "python3"
-  }
- },
+ "metadata": {},
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 5
 }