[ { "path": ".gitattributes", "content": "notebooks/* linguist-language=Python" }, { "path": ".github/workflows/ci.yml", "content": "name: CI\n\non:\n pull_request:\n push:\n branches:\n - \"**\"\n\njobs:\n checks:\n runs-on: ubuntu-latest\n strategy:\n fail-fast: false\n matrix:\n python-version: [ \"3.10\", \"3.11\" ]\n steps:\n - uses: actions/checkout@v2\n - uses: actions/setup-python@v4\n with:\n python-version: ${{ matrix.python-version }}\n - run: pip install -r dev-requirements.txt\n - run: pre-commit run -a\n - run: pytest --nbval notebooks\n" }, { "path": ".gitignore", "content": ".DS_Store\n*ipynb_checkpoints*\n.idea*\n.pytest_cache*\n.tox*\n*pycache*\nsync-*.sh\ntmp.txt\nmy_log.txt\n" }, { "path": ".pre-commit-config.yaml", "content": "repos:\n - repo: local\n hooks:\n - id: clear-nb-output\n name: clear-nb-output\n files: \\.ipynb$\n language: system\n entry: jupyter nbconvert --ClearOutputPreprocessor.enabled=True --inplace\n - id: black\n name: black\n entry: black\n language: system\n files: \\.(py|ipynb)$\n - id: pyupgrade\n name: pyupgrade\n entry: nbqa pyupgrade --py310-plus\n language: system\n files: \\.(py|ipynb)$\n" }, { "path": "CONTRIBUTING.md", "content": "# Contributing\n\nIf you spot a typo or the content does not make sense in some way, feel free to open an issue or directly create a PR.\n\nI am open for enhancement ideas and feature requests. If there's some topic you'd like to see a notebook about, feel free to open an issue and request it there.\n \n## Development\nInstall development dependencies\n```\npip install -r dev-requirements.txt\n```\n\n#### Generating html\n```\npython scripts/notebook_to_html.py \n```\n\n#### Testing\n```\npytest --nbval notebooks\n```\n\n#### pre-commit\n```\npre-commit install\n```\nand it'll automatically run all the pre-commit hooks for each commit. \n" }, { "path": "LICENSE", "content": "MIT License\n\nCopyright (c) 2023 jerry-git\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n" }, { "path": "README.md", "content": "

\n \"logo\"/\n

\n\n# Learn Python 3\n\n## Introduction\n\nThis repository contains a collection of materials for teaching/learning Python 3 (3.10+).\n\n#### Requirements\n* Have Python 3.10 or newer installed. You can check the version by typing `python3 --version` in your command line. You can download the latest Python version from [here](https://www.python.org/downloads/).\n* Have [Jupyter Notebook installed](http://jupyter.readthedocs.io/en/latest/install.html). `pip install jupyter` is sufficient in most cases.\n\nIf you can not access Python and/or Jupyter Notebook on your machine, you can still follow the web based materials. However, you should be able to use Jupyter Notebook in order to complete the exercises.\n\n#### Usage (locally)\n\n1. Clone or download this repository.\n2. Run `jupyter notebook` command in your command line in the repository directory.\n3. Jupyter Notebook session will open in the browser and you can start navigating through the materials.\n\n#### Usage (Binder in the cloud)\n\nYou can also just use [Binder:](https://mybinder.org/) By clicking of this [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jerry-git/learn-python3/master) badge, the project is opened in a Jupyter instance in the cloud and you can then navigate to the folders containing the notebooks and start them each and interactively explore them! \n\n#### Contributing\nSee [contributing](https://github.com/jerry-git/learn-python3/blob/master/CONTRIBUTING.md) guide.\n\n\n## Beginner\n1. [Strings](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/01_strings.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/01_strings.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/01_strings_exercise.ipynb)\n2. [Numbers](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/02_numbers.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/02_numbers.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/02_numbers_exercise.ipynb)\n3. [Conditionals](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/03_conditionals.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/03_conditionals.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/03_conditionals_exercise.ipynb)\n4. [Lists](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/04_lists.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/04_lists.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/04_lists_exercise.ipynb)\n5. [Dictionaries](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/05_dictionaries.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/05_dictionaries.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/05_dictionaries_exercise.ipynb)\n6. [For loops](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/06_for_loops.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/06_for_loops.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/06_for_loops_exercise.ipynb)\n7. [Functions](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/07_functions.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/07_functions.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/07_functions_exercise.ipynb)\n8. [Testing with pytest - part 1](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/08_testing1.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/08_testing1.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/08_testing1_exercise.ipynb)\n9. Recap exercise 1 [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/09_recap1_exercise.ipynb)\n10. [File I\\O](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/10_file_io.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/10_file_io.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/10_file_io_exercise.ipynb)\n11. [Classes](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/11_classes.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/11_classes.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/11_classes_exercise.ipynb)\n12. [Exceptions](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/12_exceptions.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/12_exceptions.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/12_exceptions_exercise.ipynb)\n13. [Modules and packages](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/13_modules_and_packages.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/13_modules_and_packages.ipynb)\n14. [Debugging](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/14_debugging.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/14_debugging.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/14_debugging_exercise.ipynb)\n15. [Goodies of the Standard Library - part 1](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/15_std_lib.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/15_std_lib.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/15_std_lib1_exercise.ipynb)\n16. [Testing with pytest - part 2](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/16_testing2.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/16_testing2.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/16_testing2_exercise.ipynb)\n17. [Virtual environment](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/17_venv.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/17_venv.ipynb)\n18. [Project structure](https://jerry-git.github.io/learn-python3/notebooks/beginner/html/18_project_structure.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/notebooks/18_project_structure.ipynb)\n19. Recap exercise 2 [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/beginner/exercises/19_recap2_exercise.ipynb)\n\n\n## Intermediate\n\n#### Idiomatic Python\nPython is a powerful language which contains many features not presented in most other programming languages. Idiomatic section will cover some of these Pythonic features in detail. These materials are especially useful for people with background in other programming languages.\n\n1. [Idiomatic loops](https://jerry-git.github.io/learn-python3/notebooks/intermediate/html/01_idiomatic_loops.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/notebooks/01_idiomatic_loops.ipynb)\n2. [Idiomatic dictionaries](https://jerry-git.github.io/learn-python3/notebooks/intermediate/html/02_idiomatic_dicts.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/notebooks/02_idiomatic_dicts.ipynb)\n3. [Idiomatic Python - miscellaneous part 1](https://jerry-git.github.io/learn-python3/notebooks/intermediate/html/03_idiomatic_misc1.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/notebooks/03_idiomatic_misc1.ipynb)\n4. [Idiomatic Python - miscellaneous part 2](https://jerry-git.github.io/learn-python3/notebooks/intermediate/html/04_idiomatic_misc2.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/notebooks/04_idiomatic_misc2.ipynb)\n5. Idiomatic Python exercise [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/exercises/05_idiomatic_python_exercise.ipynb)\n\n#### Step up your `pytest` game\n1. [Efficient use of fixtures](https://jerry-git.github.io/learn-python3/notebooks/intermediate/html/01_pytest_fixtures.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/notebooks/01_pytest_fixtures.ipynb)\n\n#### Best practices\nA list of best development practices for Python projects. Most of the practices listed here are also applicable for other languages, however the presented tooling focuses mainly on Python.\n1. [Best practices](https://jerry-git.github.io/learn-python3/notebooks/intermediate/html/01_best_practices.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/notebooks/01_best_practices.ipynb)\n\n#### General topics\n1. [Goodies of the Standard Library - part 2](https://jerry-git.github.io/learn-python3/notebooks/intermediate/html/01_std_lib2.html) [[notebook]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/notebooks/01_std_lib2.ipynb) [[exercise]](http://nbviewer.jupyter.org/github/jerry-git/learn-python3/blob/master/notebooks/intermediate/exercises/01_std_lib2_exercise.ipynb)\n\n\n## Credits\n* Logo: Abdur-Rahmaan Janhangeer, [@Abdur-rahmaanJ](https://github.com/Abdur-rahmaanJ)\n" }, { "path": "_config.yml", "content": "theme: jekyll-theme-slate" }, { "path": "dev-requirements.txt", "content": "black[jupyter]\njupyter\nnbqa[toolchain]\nnbval\npre-commit\npytest\n" }, { "path": "notebooks/beginner/data/empty_file.txt", "content": "" }, { "path": "notebooks/beginner/data/numbers.txt", "content": "1\n2.5\n16\n4\n5\n12\n15\n16\n18\n100" }, { "path": "notebooks/beginner/data/random_data.txt", "content": "78, 25, 4, 87, 18, 77, 94, 37, 22, 11, 28, 43, 49, 79, 75, 74, 70, 20, 50, 46" }, { "path": "notebooks/beginner/data/simple_file.txt", "content": "First line\nSecond line\nThird\nAnd so the story goes!" }, { "path": "notebooks/beginner/data/simple_file_with_empty_lines.txt", "content": "The Title of the Story\n\nFirst paragraph with some\nnonsense words.\n\nThen we move to second paragraph and so on." }, { "path": "notebooks/beginner/exercises/01_strings_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Fill missing pieces\\n\",\n \"Fill `____` pieces below to have correct values for `lower_cased`, `stripped` and `stripped_lower_case` variables.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"original = \\\" Python strings are COOL! \\\"\\n\",\n \"lower_cased = original._____\\n\",\n \"stripped = ____.strip()\\n\",\n \"stripped_lower_cased = original._____._____\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's verify that the implementation is correct by running the cell below. `assert` will raise `AssertionError` if the statement is not true. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert lower_cased == \\\" python strings are cool! \\\"\\n\",\n \"assert stripped == \\\"Python strings are COOL!\\\"\\n\",\n \"assert stripped_lower_cased == \\\"python strings are cool!\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Prettify ugly string\\n\",\n \"Use `str` methods to convert `ugly` to wanted `pretty`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"ugly = \\\" tiTle of MY new Book\\\\n\\\\n\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation:\\n\",\n \"pretty = \\\"TODO\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's make sure that it does what we want. `assert` raises [`AssertionError`](https://docs.python.org/3/library/exceptions.html#AssertionError) if the statement is not `True`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"pretty: {pretty}\\\")\\n\",\n \"assert pretty == \\\"Title Of My New Book\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 3. Format string based on existing variables\\n\",\n \"Create `sentence` by using `verb`, `language`, and `punctuation` and any other strings you may need.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"verb = \\\"is\\\"\\n\",\n \"language = \\\"Python\\\"\\n\",\n \"punctuation = \\\"!\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation:\\n\",\n \"sentence = \\\"TODO\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"sentence: {sentence}\\\")\\n\",\n \"assert sentence == \\\"Learning Python is fun!\\\"\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 1\n}\n" }, { "path": "notebooks/beginner/exercises/02_numbers_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Creating formulas\\n\",\n \"Write the following mathematical formula in Python:\\n\",\n \"\\n\",\n \"\\\\begin{align}\\n\",\n \" result = 6a^3 - \\\\frac{8b^2 }{4c} + 11\\n\",\n \"\\\\end{align}\\n\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"a = 2\\n\",\n \"b = 3\\n\",\n \"c = 2\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your formula here:\\n\",\n \"result = \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert result == 50\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Floating point pitfalls\\n\",\n \"Show that `0.1 + 0.2 == 0.3`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your solution here\\n\",\n \"\\n\",\n \"# This won't work:\\n\",\n \"# assert 0.1 + 0.2 == 0.3\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/03_conditionals_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. `if-elif-else`\\n\",\n \"Fill missing pieces (`____`) of the following code such that prints make sense.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"name = \\\"John Doe\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if ____:\\n\",\n \" print(f'Name \\\"{name}\\\" is more than 20 chars long')\\n\",\n \" length_description = \\\"long\\\"\\n\",\n \"elif ____:\\n\",\n \" print(f'Name \\\"{name}\\\" is more than 15 chars long')\\n\",\n \" length_description = \\\"semi long\\\"\\n\",\n \"elif ____:\\n\",\n \" print(f'Name \\\"{name}\\\" is more than 10 chars long')\\n\",\n \" length_description = \\\"semi long\\\"\\n\",\n \"elif ____:\\n\",\n \" print(f'Name \\\"{name}\\\" is 8, 9 or 10 chars long')\\n\",\n \" length_description = \\\"semi short\\\"\\n\",\n \"else:\\n\",\n \" print(f'Name \\\"{name}\\\" is a short name')\\n\",\n \" length_description = \\\"short\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert length_description == \\\"semi short\\\"\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/04_lists_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Fill the missing pieces\\n\",\n \"Fill the `____` parts of the code below.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Let's create an empty list\\n\",\n \"my_list = ____\\n\",\n \"\\n\",\n \"# Let's add some values\\n\",\n \"my_list.____(\\\"Python\\\")\\n\",\n \"my_list.____(\\\"is ok\\\")\\n\",\n \"my_list.____(\\\"sometimes\\\")\\n\",\n \"\\n\",\n \"# Let's remove 'sometimes'\\n\",\n \"my_list.____(\\\"sometimes\\\")\\n\",\n \"\\n\",\n \"# Let's change the second item\\n\",\n \"my_list[____] = \\\"is neat\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"# Let's verify that it's correct\\n\",\n \"assert my_list == [\\\"Python\\\", \\\"is neat\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Create a new list without modifiying the original one\\n\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"original = [\\\"I\\\", \\\"am\\\", \\\"learning\\\", \\\"hacking\\\", \\\"in\\\"]\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\\n\",\n \"modified = \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert original == [\\\"I\\\", \\\"am\\\", \\\"learning\\\", \\\"hacking\\\", \\\"in\\\"]\\n\",\n \"assert modified == [\\\"I\\\", \\\"am\\\", \\\"learning\\\", \\\"lists\\\", \\\"in\\\", \\\"Python\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 3. Create a merged sorted list\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"list1 = [6, 12, 5]\\n\",\n \"list2 = [6.2, 0, 14, 1]\\n\",\n \"list3 = [0.9]\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\\n\",\n \"my_list = \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"print(my_list)\\n\",\n \"assert my_list == [14, 12, 6.2, 6, 5, 1, 0.9, 0]\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/05_dictionaries_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Populating a dictionary\\n\",\n \"Create a dictionary by using all the given variables.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"first_name = \\\"John\\\"\\n\",\n \"last_name = \\\"Doe\\\"\\n\",\n \"favorite_hobby = \\\"Python\\\"\\n\",\n \"sports_hobby = \\\"gym\\\"\\n\",\n \"age = 82\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation\\n\",\n \"my_dict = \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert my_dict == {\\\"name\\\": \\\"John Doe\\\", \\\"age\\\": 82, \\\"hobbies\\\": [\\\"Python\\\", \\\"gym\\\"]}\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Accessing and merging dictionaries\\n\",\n \"Combine `dict1`, `dict2`, and `dict3` into `my_dict`. In addition, get the value of `special_key` from `my_dict` into a `special_value` variable. Note that original dictionaries should stay untouched and `special_key` should be removed from `my_dict`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"dict1 = dict(key1=\\\"This is not that hard\\\", key2=\\\"Python is still cool\\\")\\n\",\n \"dict2 = {\\\"key1\\\": 123, \\\"special_key\\\": \\\"secret\\\"}\\n\",\n \"# This is also a away to initialize a dict (list of tuples)\\n\",\n \"dict3 = dict([(\\\"key2\\\", 456), (\\\"keyX\\\", \\\"X\\\")])\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# 'Your impelementation'\\n\",\n \"my_dict = \\n\",\n \"special_value = \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert my_dict == {\\\"key1\\\": 123, \\\"key2\\\": 456, \\\"keyX\\\": \\\"X\\\"}\\n\",\n \"assert special_value == \\\"secret\\\"\\n\",\n \"\\n\",\n \"# Let's check that the originals are untouched\\n\",\n \"assert dict1 == {\\\"key1\\\": \\\"This is not that hard\\\", \\\"key2\\\": \\\"Python is still cool\\\"}\\n\",\n \"assert dict2 == {\\\"key1\\\": 123, \\\"special_key\\\": \\\"secret\\\"}\\n\",\n \"assert dict3 == {\\\"key2\\\": 456, \\\"keyX\\\": \\\"X\\\"}\"\n ]\n }\n ],\n \"metadata\": {\n \"celltoolbar\": \"Edit Metadata\",\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 1\n}\n" }, { "path": "notebooks/beginner/exercises/06_for_loops_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Fill the missing pieces\\n\",\n \"Fill the `____` parts in the code below.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"words = [\\\"PYTHON\\\", \\\"JOHN\\\", \\\"chEEse\\\", \\\"hAm\\\", \\\"DOE\\\", \\\"123\\\"]\\n\",\n \"upper_case_words = []\\n\",\n \"\\n\",\n \"for ____ in words:\\n\",\n \" if ____.isupper():\\n\",\n \" ____.append(____)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert upper_case_words == [\\\"PYTHON\\\", \\\"JOHN\\\", \\\"DOE\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Calculate the sum of dict values\\n\",\n \"Calculate the sum of the values in `magic_dict` by taking only into account numeric values (hint: see [isinstance](https://docs.python.org/3/library/functions.html#isinstance)). \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"magic_dict = dict(val1=44, val2=\\\"secret value\\\", val3=55.0, val4=1)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation\\n\",\n \"sum_of_values = \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert sum_of_values == 100\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 3. Create a list of strings based on a list of numbers\\n\",\n \"The rules:\\n\",\n \"* If the number is a multiple of five and odd, the string should be `'five odd'`\\n\",\n \"* If the number is a multiple of five and even, the string should be `'five even'`\\n\",\n \"* If the number is odd, the string is `'odd'`\\n\",\n \"* If the number is even, the string is `'even'`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"numbers = [1, 3, 4, 6, 81, 80, 100, 95]\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation\\n\",\n \"my_list = \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert my_list == [\\n\",\n \" \\\"odd\\\",\\n\",\n \" \\\"odd\\\",\\n\",\n \" \\\"even\\\",\\n\",\n \" \\\"even\\\",\\n\",\n \" \\\"odd\\\",\\n\",\n \" \\\"five even\\\",\\n\",\n \" \\\"five even\\\",\\n\",\n \" \\\"five odd\\\",\\n\",\n \"]\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/07_functions_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Fill the missing pieces of the `count_even_numbers` function\\n\",\n \"Fill `____` pieces of the `count_even_numbers` implemention in order to pass the assertions. You can assume that `numbers` argument is a list of integers.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"____ count_even_numbers(numbers):\\n\",\n \" count = 0\\n\",\n \" for num in ____:\\n\",\n \" if ____ % 2 == ____:\\n\",\n \" count += ____\\n\",\n \" _____ _____\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert count_even_numbers([1, 2, 3, 4, 5, 6]) == 3\\n\",\n \"assert count_even_numbers([1, 3, 5, 7]) == 0\\n\",\n \"assert count_even_numbers([-2, 2, -10, 8]) == 4\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Searching for wanted people\\n\",\n \"Implement `find_wanted_people` function which takes a list of names (strings) as argument. The function should return a list of names which are present both in `WANTED_PEOPLE` and in the name list given as argument to the function.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"WANTED_PEOPLE = [\\\"John Doe\\\", \\\"Clint Eastwood\\\", \\\"Chuck Norris\\\"]\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"people_to_check1 = [\\\"Donald Duck\\\", \\\"Clint Eastwood\\\", \\\"John Doe\\\", \\\"Barack Obama\\\"]\\n\",\n \"wanted1 = find_wanted_people(people_to_check1)\\n\",\n \"assert len(wanted1) == 2\\n\",\n \"assert \\\"John Doe\\\" in wanted1\\n\",\n \"assert \\\"Clint Eastwood\\\" in wanted1\\n\",\n \"\\n\",\n \"people_to_check2 = [\\\"Donald Duck\\\", \\\"Mickey Mouse\\\", \\\"Zorro\\\", \\\"Superman\\\", \\\"Robin Hood\\\"]\\n\",\n \"wanted2 = find_wanted_people(people_to_check2)\\n\",\n \"assert wanted2 == []\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 3. Counting average length of words in a sentence\\n\",\n \"Create a function `average_length_of_words` which takes a string as an argument and returns the average length of the words in the string. You can assume that there is a single space between each word and that the input does not have punctuation. The result should be rounded to one decimal place (hint: see [`round`](https://docs.python.org/3/library/functions.html#round)).\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert average_length_of_words(\\\"only four lett erwo rdss\\\") == 4\\n\",\n \"assert average_length_of_words(\\\"one two three\\\") == 3.7\\n\",\n \"assert average_length_of_words(\\\"one two three four\\\") == 3.8\\n\",\n \"assert average_length_of_words(\\\"\\\") == 0\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/08_testing1_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Let's make sure pytest and ipytest packages are installed\\n\",\n \"# ipytest is required for running pytest inside Jupyter notebooks\\n\",\n \"import sys\\n\",\n \"\\n\",\n \"!{sys.executable} -m pip install pytest\\n\",\n \"!{sys.executable} -m pip install ipytest\\n\",\n \"\\n\",\n \"# These are needed for running pytest inside Jupyter notebooks\\n\",\n \"import ipytest\\n\",\n \"\\n\",\n \"ipytest.autoconfig()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Creating your first test case\\n\",\n \"There is an implementation for `get_divisible_by_five` function in the cell below. Your task is to create a test case for this function to verify that it works correctly.\\n\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"def get_divisible_by_five(numbers):\\n\",\n \" \\\"\\\"\\\"Returns a list of numbers which are divisible by five in the list got as an argument\\\"\\\"\\\"\\n\",\n \" result = []\\n\",\n \" for num in numbers:\\n\",\n \" if not num % 5:\\n\",\n \" result.append(num)\\n\",\n \"\\n\",\n \" return result\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest\\n\",\n \"\\n\",\n \"def test_get_divisible_by_five():\\n\",\n \" # Your implementation here\\n\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/09_recap1_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Super vowels\\n\",\n \"Implement `super_vowels` function which takes a string as an argument and returns a modified version of that string. In the return value of `super_vowels`, all vowels should be in upper case whereas all consonants should be in lower case. The vowels are listed in the `VOWELS` variable.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"VOWELS = [\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\"]\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert super_vowels(\\\"hi wassup!\\\") == \\\"hI wAssUp!\\\"\\n\",\n \"assert super_vowels(\\\"HOw aRE You?\\\") == \\\"hOw ArE yOU?\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Playing board\\n\",\n \"Implement `get_playing_board` function which takes an integer as an argument. The function should return a string which resemples a playing board (e.g. a chess board). The board should contain as many rows and columns as requested by the interger argument. See the cell below for examples of desired behavior.\\n\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"board_of_5 = \\\" * * \\\\n\\\" \\\"* * *\\\\n\\\" \\\" * * \\\\n\\\" \\\"* * *\\\\n\\\" \\\" * * \\\\n\\\"\\n\",\n \"\\n\",\n \"board_of_10 = (\\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 \"assert get_playing_board(5) == board_of_5\\n\",\n \"assert get_playing_board(10) == board_of_10\\n\",\n \"\\n\",\n \"print(get_playing_board(50))\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/10_file_io_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"# EXECUTE THIS ONE FIRST!\\n\",\n \"\\n\",\n \"from pathlib import Path\\n\",\n \"\\n\",\n \"# Constants for the exercises:\\n\",\n \"WORKING_DIR = Path.cwd()\\n\",\n \"DATA_DIR = WORKING_DIR.parent / \\\"data\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Sum numbers listed in a file\\n\",\n \"Fill ____ pieces of the code below. `sum_numbers_in_file` function takes a input file path as argument, reads the numbers listed in the input file and returns the sum of those numbers. You can assume that each line contains exactly one numeric value.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def sum_numbers_in_file(input_file):\\n\",\n \" total = 0\\n\",\n \" with ____(input_file) as ____:\\n\",\n \" for line in ____:\\n\",\n \" ____ = line.strip() # Remove potential white space\\n\",\n \" total += float(____)\\n\",\n \" return _____\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"in_file = DATA_DIR / \\\"numbers.txt\\\"\\n\",\n \"assert sum_numbers_in_file(in_file) == 189.5\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Reading first word from each line of a file\\n\",\n \"Implement `find_first_words` function which takes an input file path as argument. The function should find the first word of each line in the file and return these words as a list. If a line is empty, the returned list should contain an empty string for that line.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"in_file1 = DATA_DIR / \\\"simple_file.txt\\\"\\n\",\n \"in_file2 = DATA_DIR / \\\"simple_file_with_empty_lines.txt\\\"\\n\",\n \"\\n\",\n \"expected_file_1 = [\\\"First\\\", \\\"Second\\\", \\\"Third\\\", \\\"And\\\"]\\n\",\n \"assert find_first_words(in_file1) == expected_file_1\\n\",\n \"\\n\",\n \"expected_file_2 = [\\\"The\\\", \\\"\\\", \\\"First\\\", \\\"nonsense\\\", \\\"\\\", \\\"Then\\\"]\\n\",\n \"assert find_first_words(in_file2) == expected_file_2\"\n ]\n }\n ],\n \"metadata\": {\n \"celltoolbar\": \"Edit Metadata\",\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/11_classes_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Fill the missing pieces of the `Calculator` class\\n\",\n \"Fill `____` pieces of the `Calculator` implemention in order to pass the assertions.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Calculator:\\n\",\n \" def __init__(self, var1, ____):\\n\",\n \" self.____ = var1\\n\",\n \" self.____ = _____\\n\",\n \"\\n\",\n \" def calculate_power(self):\\n\",\n \" return self.____**____.____\\n\",\n \"\\n\",\n \" def calculate_sum(____, var3):\\n\",\n \" return ____.____ + ____.____ + var3\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"calc = Calculator(2, 3)\\n\",\n \"assert calc.calculate_power() == 8\\n\",\n \"assert calc.calculate_sum(4) == 9\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Finalize `StringManipulator` class\\n\",\n \"Fill `____` pieces and create implementation for `stripped_title()`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class StringManipulator:\\n\",\n \" \\\"\\\"\\\"____\\\"\\\"\\\"\\n\",\n \" \\n\",\n \" category = ____\\n\",\n \" \\n\",\n \" def __init__(self, original):\\n\",\n \" self.string = ____\\n\",\n \" \\n\",\n \" def reverse_words(self):\\n\",\n \" words = self.string.____\\n\",\n \" self.string = ' '.join(reversed(____))\\n\",\n \" \\n\",\n \" def make_title(self):\\n\",\n \" # Create implementation for this\\n\",\n \" \\n\",\n \" def get_manipulated(____):\\n\",\n \" return self._____\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert StringManipulator.__doc__ == \\\"Docstring of StringManipulator\\\"\\n\",\n \"assert StringManipulator.category == \\\"Manipulator\\\"\\n\",\n \"\\n\",\n \"str_manip = StringManipulator(\\\"cOOL pyThON\\\")\\n\",\n \"\\n\",\n \"str_manip.reverse_words()\\n\",\n \"assert str_manip.get_manipulated() == \\\"pyThON cOOL\\\"\\n\",\n \"\\n\",\n \"str_manip.make_title()\\n\",\n \"assert str_manip.get_manipulated() == \\\"Python Cool\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 3. Create `Dog` class\\n\",\n \"Create `Dog` class which has the following specification:\\n\",\n \"* Dogs consume their energy by barking and gain energy by sleeping\\n\",\n \"* A fresh `Dog` instance has 10 units of energy\\n\",\n \"* `Dog` has a method `sleep` which gives 2 units of energy\\n\",\n \"* `Dog` has a method `bark` which consumes 1 unit of energy\\n\",\n \"* `Dog` has a method `get_energy` which returns the amount of energy left \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Dog:\\n\",\n \" # Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"doge = Dog()\\n\",\n \"assert doge.get_energy() == 10\\n\",\n \"\\n\",\n \"doge.bark()\\n\",\n \"doge.bark()\\n\",\n \"doge.bark()\\n\",\n \"assert doge.get_energy() == 7\\n\",\n \"\\n\",\n \"doge.sleep()\\n\",\n \"assert doge.get_energy() == 9\\n\",\n \"\\n\",\n \"another_doge = Dog()\\n\",\n \"assert another_doge.get_energy() == 10\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/12_exceptions_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Dealing with exceptions\\n\",\n \"Fill `____` parts of the implementation below. `sum_of_list` function takes a list as argument and calculates the sum of values in the list. If some element in the list can not be converted to a numeric value, it should be ignored from the sum.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def sum_of_list(values):\\n\",\n \" ____ = 0\\n\",\n \" for val in values:\\n\",\n \" ____:\\n\",\n \" numeric_val = float(val)\\n\",\n \" ____ ____ as e:\\n\",\n \" ____\\n\",\n \" ____ += numeric_val\\n\",\n \" return ____\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"list1 = [1, 2, 3]\\n\",\n \"list2 = [\\\"1\\\", 2.5, \\\"3.0\\\"]\\n\",\n \"list3 = [\\\"\\\", \\\"1\\\"]\\n\",\n \"list4 = []\\n\",\n \"list5 = [\\\"John\\\", \\\"Doe\\\", \\\"was\\\", \\\"here\\\"]\\n\",\n \"nasty_list = [KeyError(), [], dict()]\\n\",\n \"\\n\",\n \"assert sum_of_list(list1) == 6\\n\",\n \"assert sum_of_list(list2) == 6.5\\n\",\n \"assert sum_of_list(list3) == 1\\n\",\n \"assert sum_of_list(list4) == 0\\n\",\n \"assert sum_of_list(list5) == 0\\n\",\n \"assert sum_of_list(nasty_list) == 0\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Using custom exceptions\\n\",\n \"Implement `verify_short_string` function which takes a single string as argument. If the length of the input string is more than ten characters, the function should raise `TooLongString` exception (note: you have to create `TooLongString` yourself). The function does not have to return anything. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"# These should not raise\\n\",\n \"verify_short_string(\\\"short\\\")\\n\",\n \"verify_short_string(\\\"10 chars\\\")\\n\",\n \"\\n\",\n \"# This should raise\\n\",\n \"try:\\n\",\n \" verify_short_string(\\\"this is long\\\")\\n\",\n \"except TooLongString as e:\\n\",\n \" # This is ok\\n\",\n \" pass\\n\",\n \"else:\\n\",\n \" # This means that there was no exception\\n\",\n \" assert False\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/14_debugging_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Identifying bugs in code\\n\",\n \"The following `stripped_reversed_lowercase` function contains at least one bug. You can see this by running the code in the cell below which tests the functionality of the `stripped_reversed_lowercase` function.\\n\",\n \"\\n\",\n \"Set trace at the beginning of `stripped_reversed_lowercase` and use debugger to solve the bug(s). Execute the code line by line and print variables used in the function to understand what's going wrong. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def stripped_reversed_lowercase(original):\\n\",\n \" # Set a breakpoint here and start debugging\\n\",\n \" # from IPython.core.debugger import Pdb; Pdb().set_trace()\\n\",\n \" stripped = original.lstrip()\\n\",\n \" reversed = \\\" \\\".join(reversed(stripped))\\n\",\n \" reversed.lower()\\n\",\n \" return reversed\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"# Let's verify it works\\n\",\n \"original = \\\" \\\\n Original String \\\"\\n\",\n \"result = stripped_reversed_lowercase(original)\\n\",\n \"assert result == \\\"gnirts lanigiro\\\"\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/15_std_lib1_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Playing with datetimes\\n\",\n \"You're given a naive datetime, see `NAIVE_DT` variable below. Although this variable is naive, you happen to know that the time specified by `NAIVE_DT` is in UTC.\\n\",\n \"\\n\",\n \"Based on this information, your task is to create new datetime variables by converting `NAIVE_DT` to UTC and then to time in Sydney and Los Angeles. Use the following variable names: `utc_dt`, `sydney_dt`, and `la_dt`. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"import datetime as dt\\n\",\n \"from zoneinfo import ZoneInfo, available_timezones\\n\",\n \"\\n\",\n \"NAIVE_DT = dt.datetime(2000, 1, 1, 10)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If you don't know the timezone name you're looking for, this may be helpful:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"for tz in available_timezones():\\n\",\n \" print(tz)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Now create `utc_dt`, `sydney_dt`, and `la_dt`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's verify that the solution is correct.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"assert utc_dt.isoformat() == \\\"2000-01-01T10:00:00+00:00\\\"\\n\",\n \"assert sydney_dt.isoformat() == \\\"2000-01-01T21:00:00+11:00\\\"\\n\",\n \"assert la_dt.isoformat() == \\\"2000-01-01T02:00:00-08:00\\\"\\n\",\n \"\\n\",\n \"print(\\\"All good!\\\")\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/16_testing2_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Let's make sure pytest and ipytest packages are installed\\n\",\n \"# ipytest is required for running pytest inside Jupyter notebooks\\n\",\n \"import sys\\n\",\n \"\\n\",\n \"!{sys.executable} -m pip install pytest\\n\",\n \"!{sys.executable} -m pip install ipytest\\n\",\n \"\\n\",\n \"# These are needed for running pytest inside Jupyter notebooks\\n\",\n \"import ipytest\\n\",\n \"import pytest\\n\",\n \"\\n\",\n \"ipytest.autoconfig()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Finalize test cases\\n\",\n \"The testing part of the `TodoList` implementation is incomplete. Fill `____` parts of the tests. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"class TodoNotFound(Exception):\\n\",\n \" pass\\n\",\n \"\\n\",\n \"\\n\",\n \"class TodoList:\\n\",\n \" def __init__(self):\\n\",\n \" self._todo = {}\\n\",\n \" self._done = {}\\n\",\n \" self._task_counter = 1\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def todo_tasks(self):\\n\",\n \" return self._todo\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def done_tasks(self):\\n\",\n \" return self._done\\n\",\n \"\\n\",\n \" def add(self, task):\\n\",\n \" self._todo[self._task_counter] = task\\n\",\n \" self._task_counter += 1\\n\",\n \"\\n\",\n \" def complete(self, number):\\n\",\n \" if number not in self._todo:\\n\",\n \" raise TodoNotFound(f\\\"{number} not in todos\\\")\\n\",\n \"\\n\",\n \" task = self._todo.pop(number)\\n\",\n \" self._done[number] = task\\n\",\n \"\\n\",\n \" def remove(self, number):\\n\",\n \" if number not in self._todo:\\n\",\n \" raise TodoNotFound(f\\\"{number} not in todos\\\")\\n\",\n \"\\n\",\n \" del self._todo[number]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Finalize tests for `TodoList`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.____\\n\",\n \"def todo_list():\\n\",\n \" tl = TodoList()\\n\",\n \" tl.add('buy milk')\\n\",\n \" tl.add('take dog out')\\n\",\n \" tl.add('learn pytest fixtures')\\n\",\n \" ____ ____\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_todo_tasks_property(todo_list):\\n\",\n \" todo = todo_list.todo_tasks\\n\",\n \" assert todo == {\\n\",\n \" 1: 'buy milk',\\n\",\n \" 2: 'take dog out',\\n\",\n \" 3: 'learn pytest fixtures'\\n\",\n \" }\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_add(____):\\n\",\n \" todo_list.add('check pytest docs')\\n\",\n \" todos = todo_list.todo_tasks\\n\",\n \" assert todos[4] == ____\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_complete(todo_list):\\n\",\n \" # Make sure there is not done tasks yet\\n\",\n \" assert not todo_list.done_tasks\\n\",\n \"\\n\",\n \" todo_list.complete(3)\\n\",\n \" done = todo_list.____\\n\",\n \" todo = todo_list.____\\n\",\n \" assert done[3] == 'learn pytest fixtures'\\n\",\n \" assert 3 not in ____\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_complete_with_unknown_task_number(todo_list):\\n\",\n \" # This is how you can test that a certain exception is raised\\n\",\n \" with pytest.raises(TodoNotFound):\\n\",\n \" todo_list.complete(10)\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_remove(todo_list):\\n\",\n \" todo_list.remove(1)\\n\",\n \" done = todo_list.done_tasks\\n\",\n \" todo = todo_list.todo_tasks\\n\",\n \"\\n\",\n \" assert 1 not in ____\\n\",\n \" # Make sure it was not moved to done\\n\",\n \" ____ not done\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_remove_with_unknown_task_number(todo_list):\\n\",\n \" with pytest.____(____):\\n\",\n \" todo_list.remove(12)\\n\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Testing the [Fibonacci numbers](https://en.wikipedia.org/wiki/Fibonacci_number)\\n\",\n \"\\n\",\n \"Implement a test for the `fibonacci` function. Use `pytest.mark.parametrize` and test at least with numbers: 0, 1, 2, 3, and 10. You can find the expected results and more information about the Fibonacci numbers [here](https://en.wikipedia.org/wiki/Fibonacci_number).\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"def fibonacci(number):\\n\",\n \" if number in [0, 1]:\\n\",\n \" return number\\n\",\n \" return fibonacci(number - 1) + fibonacci(number - 2)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest\\n\",\n \"\\n\",\n \"# Your implementation here\\n\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/exercises/19_recap2_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. [Rock-paper-scissors](https://en.wikipedia.org/wiki/Rock%E2%80%93paper%E2%80%93scissors) \\n\",\n \"Implement `rock_paper_scissors` function which takes the player's rock-paper-scissors choice as an input (as integer), randomly selects the choice of the computer and reveals it (prints) and finally announces (prints) the result. The function should return `PLAYER_WINS`, `COMPUTER_WINS` or `TIE`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"# Constants, you should use these in your implementation\\n\",\n \"ROCK = 1\\n\",\n \"PAPER = 2\\n\",\n \"SCISSORS = 3\\n\",\n \"\\n\",\n \"PLAYER_WINS = \\\"Player wins!! Woop woop!\\\"\\n\",\n \"COMPUTER_WINS = \\\"Robocop wins :-(\\\"\\n\",\n \"TIE = \\\"It's a tie!\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Once you have finished the implementation of `rock_paper_scissors` function, you can check if it works as expected by playing the game:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def play_rps():\\n\",\n \" print(\\\"Welcome to play rock-paper-scissors\\\")\\n\",\n \" print(\\\"The options are:\\\\nrock: 1\\\\npaper: 2\\\\nscissors: 3\\\")\\n\",\n \"\\n\",\n \" result = TIE\\n\",\n \" while result == TIE:\\n\",\n \" player_choice = input(\\\"Give your choice\\\\n\\\")\\n\",\n \"\\n\",\n \" if not player_choice in [\\\"1\\\", \\\"2\\\", \\\"3\\\"]:\\n\",\n \" print(\\\"Invalid choice\\\")\\n\",\n \" continue\\n\",\n \"\\n\",\n \" result = rock_paper_scissors(int(player_choice))\\n\",\n \"\\n\",\n \"\\n\",\n \"if __name__ == \\\"__main__\\\":\\n\",\n \" play_rps()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If you copy the code from above cells into a single .py file, you have a rock-paper-scissor command line game!\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. Data analyzer\\n\",\n \"Implement `DataAnalyzer` class which has the following specification:\\n\",\n \"* `__init__` takes one argument which is a path to the file to be analyzed\\n\",\n \"* `total_samples` method returns the amount of the data samples in the file\\n\",\n \"* `average` method returns the average of the data samples in the file\\n\",\n \"* `median` method returns the median of the data samples in the file\\n\",\n \"* `max_value` method returns the maximum value of the data samples in the file\\n\",\n \"* `min_value` method returns the minimum value of the data samples in the file\\n\",\n \"* `create_report` method returns a report (string) of the file in the following format:\\n\",\n \"\\n\",\n \"```\\n\",\n \"Report for \\n\",\n \"samples: x\\n\",\n \"average: x.xx\\n\",\n \"median: xx.xx\\n\",\n \"max: xx.xx\\n\",\n \"min: x.xx\\n\",\n \"```\\n\",\n \" \\n\",\n \"Note that average, median, max, and min should be presented with two decimal places in the report.\\n\",\n \"\\n\",\n \"The format of the input file is comma separated and the file contains only numeric values.\\n\",\n \"\\n\",\n \"If there is no data in the input file (empty file), `NoData` exception should be raised. Note: `NoData` should be your custom exception.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's verify it works.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"from pathlib import Path\\n\",\n \"\\n\",\n \"WORKING_DIR = Path.cwd()\\n\",\n \"DATA_DIR = WORKING_DIR.parent / \\\"data\\\"\\n\",\n \"DATA_FILE = DATA_DIR / \\\"random_data.txt\\\"\\n\",\n \"\\n\",\n \"da = DataAnalyzer(DATA_FILE)\\n\",\n \"\\n\",\n \"assert da.total_samples() == 20\\n\",\n \"assert da.average() == 49.35\\n\",\n \"assert da.median() == 47.5\\n\",\n \"assert da.max_value() == 94\\n\",\n \"assert da.min_value() == 4\\n\",\n \"\\n\",\n \"report = da.create_report()\\n\",\n \"print(report)\\n\",\n \"\\n\",\n \"expected_report = (\\n\",\n \" \\\"Report for random_data.txt\\\\n\\\"\\n\",\n \" \\\"samples: 20\\\\n\\\"\\n\",\n \" \\\"average: 49.35\\\\n\\\"\\n\",\n \" \\\"median: 47.50\\\\n\\\"\\n\",\n \" \\\"max: 94.00\\\\n\\\"\\n\",\n \" \\\"min: 4.00\\\"\\n\",\n \")\\n\",\n \"assert report == expected_report\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's check that it raises `NoData` with empty file.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"EMPTY_FILE = DATA_DIR / \\\"empty_file.txt\\\"\\n\",\n \"try:\\n\",\n \" da_empty = DataAnalyzer(EMPTY_FILE)\\n\",\n \"except NoData:\\n\",\n \" print(\\\"All ok :)\\\")\\n\",\n \"else: # There was no exception\\n\",\n \" assert False\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/html/01_strings.html", "content": "\n\n\n\n\n01_strings\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

Strings

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
my_string = "Python is my favorite programming language!"\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
my_string\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[2]:
\n\n\n\n\n
\n
'Python is my favorite programming language!'
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
type(my_string)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[3]:
\n\n\n\n\n
\n
str
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
len(my_string)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[4]:
\n\n\n\n\n
\n
43
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Respecting PEP8 with long strings

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
long_story = (\n    "Lorem ipsum dolor sit amet, consectetur adipiscing elit."\n    "Pellentesque eget tincidunt felis. Ut ac vestibulum est."\n    "In sed ipsum sit amet sapien scelerisque bibendum. Sed "\n    "sagittis purus eu diam fermentum pellentesque."\n)\nlong_story\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[5]:
\n\n\n\n\n
\n
'Lorem ipsum dolor sit amet, consectetur adipiscing elit.Pellentesque eget tincidunt felis. Ut ac vestibulum est.In sed ipsum sit amet sapien scelerisque bibendum. Sed sagittis purus eu diam fermentum pellentesque.'
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

str.replace()

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

If you don't know how it works, you can always check the help:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
help(str.replace)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Help on method_descriptor:\n\nreplace(self, old, new, count=-1, /)\n    Return a copy with all occurrences of substring old replaced by new.\n    \n      count\n        Maximum number of occurrences to replace.\n        -1 (the default value) means replace all occurrences.\n    \n    If the optional argument count is given, only the first count occurrences are\n    replaced.\n\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This will not modify my_string because replace is not done in-place.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
my_string.replace("a", "?")\nprint(my_string)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Python is my favorite programming language!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You have to store the return value of replace instead.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
my_modified_string = my_string.replace("is", "will be")\nprint(my_modified_string)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Python will be my favorite programming language!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

f-strings

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
first_name = "John"\nlast_name = "Doe"\nage = 88\nprint(f"My name is {first_name} {last_name}, you can call me {first_name}.")\nprint(f"I'm {age} years old.")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
My name is John Doe, you can call me John.\nI'm 88 years old.\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
print(f"Use '=' to also print the variable name like this: {age=}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Use '=' to also print the variable name like this: age=88\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

str.join()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
pandas = "pandas"\nnumpy = "numpy"\nrequests = "requests"\ncool_python_libs = ", ".join([pandas, numpy, requests])\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
print(f"Some cool python libraries: {cool_python_libs}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Some cool python libraries: pandas, numpy, requests\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Alternative (not as Pythonic and slower):

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
cool_python_libs = pandas + ", " + numpy + ", " + requests\nprint(f"Some cool python libraries: {cool_python_libs}")\n\ncool_python_libs = pandas\ncool_python_libs += ", " + numpy\ncool_python_libs += ", " + requests\nprint(f"Some cool python libraries: {cool_python_libs}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Some cool python libraries: pandas, numpy, requests\nSome cool python libraries: pandas, numpy, requests\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

str.upper(), str.lower(), str.title()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
mixed_case = "PyTHoN hackER"\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
mixed_case.upper()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[15]:
\n\n\n\n\n
\n
'PYTHON HACKER'
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [16]:
\n
\n
\n
mixed_case.lower()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[16]:
\n\n\n\n\n
\n
'python hacker'
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [17]:
\n
\n
\n
mixed_case.title()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[17]:
\n\n\n\n\n
\n
'Python Hacker'
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

str.strip()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [18]:
\n
\n
\n
ugly_formatted = " \\n \\t Some story to tell "\nstripped = ugly_formatted.strip()\n\nprint(f"ugly: {ugly_formatted}")\nprint(f"stripped: {stripped}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
ugly:  \n \t Some story to tell \nstripped: Some story to tell\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

str.split()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [19]:
\n
\n
\n
sentence = "three different words"\nwords = sentence.split()\nprint(words)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
['three', 'different', 'words']\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [20]:
\n
\n
\n
type(words)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[20]:
\n\n\n\n\n
\n
list
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [21]:
\n
\n
\n
secret_binary_data = "01001,101101,11100000"\nbinaries = secret_binary_data.split(",")\nprint(binaries)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
['01001', '101101', '11100000']\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Calling multiple methods in a row

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [22]:
\n
\n
\n
ugly_mixed_case = "   ThIS LooKs BAd "\npretty = ugly_mixed_case.strip().lower().replace("bad", "good")\nprint(pretty)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
this looks good\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Note that execution order is from left to right. Thus, this won't work:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [23]:
\n
\n
\n
pretty = ugly_mixed_case.replace("bad", "good").strip().lower()\nprint(pretty)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
this looks bad\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Escape characters

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [24]:
\n
\n
\n
two_lines = "First line\\nSecond line"\nprint(two_lines)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
First line\nSecond line\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [25]:
\n
\n
\n
indented = "\\tThis will be indented"\nprint(indented)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
\tThis will be indented\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/02_numbers.html", "content": "\n\n\n\n\n02_numbers\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

Numbers

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

int

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
my_int = 6\nprint(f"value: {my_int}, type: {type(my_int)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
value: 6, type: <class 'int'>\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

float

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
my_float = float(my_int)\nprint(f"value: {my_float}, type: {type(my_float)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
value: 6.0, type: <class 'float'>\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Note that division of ints produces float:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
print(1 / 1)\nprint(6 / 5)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
1.0\n1.2\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Be aware of the binary floating-point pitfalls (see Decimal for workaround):

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
val = 0.1 + 0.1 + 0.1\nprint(val == 0.3)\nprint(val)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
False\n0.30000000000000004\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Floor division //, modulus %, power **

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
7 // 5\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[5]:
\n\n\n\n\n
\n
1
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
7 % 5\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[6]:
\n\n\n\n\n
\n
2
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
2**3\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
Out[7]:
\n\n\n\n\n
\n
8
\n
\n\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

\n

decimal.Decimal

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
from decimal import Decimal\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
from_float = Decimal(0.1)\nfrom_str = Decimal("0.1")\nprint(f"from float: {from_float}\\nfrom string: {from_str}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
from float: 0.1000000000000000055511151231257827021181583404541015625\nfrom string: 0.1\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
my_decimal = Decimal("0.1")\nsum_of_decimals = my_decimal + my_decimal + my_decimal\nprint(sum_of_decimals == Decimal("0.3"))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Operator precedence in calculations

Mathematical operator precedence applies. Use brackets if you want to change the execution order:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
print(1 + 2**2 * 3 / 6)  # 1 + 4 * 3 / 6 == 1 + 12 / 6 == 1 + 2\nprint((1 + 2**2) * 3 / 6)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
3.0\n2.5\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/03_conditionals.html", "content": "\n\n\n\n\n03_conditionals\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

Conditionals

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Testing truth value

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

bool

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
print(f"type of True and False: {type(True)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
type of True and False: <class 'bool'>\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
print(f"0: {bool(0)}, 1: {bool(1)}")\nprint(f"empty list: {bool([])}, list with values: {bool(['woop'])}")\nprint(f"empty dict: {bool({})}, dict with values: {bool({'Python': 'cool'})}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0: False, 1: True\nempty list: False, list with values: True\nempty dict: False, dict with values: True\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
In [3]:
\n
\n
\n
print(f"{1 == 0}")\nprint(f"{1 != 0}")\nprint(f"{1 > 0}")\nprint(f"{1 > 1}")\nprint(f"{1 < 0}")\nprint(f"{1 < 1}")\nprint(f"{1 >= 0}")\nprint(f"{1 >= 1}")\nprint(f"{1 <= 0}")\nprint(f"{1 <= 1}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
False\nTrue\nTrue\nFalse\nFalse\nFalse\nTrue\nTrue\nFalse\nTrue\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You can combine these:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
print(f"{1 <= 2 <= 3}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

and, or, not

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
python_is_cool = True\njava_is_cool = False\nempty_list = []\nsecret_value = 3.14\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
print(f"Python and java are both cool: {python_is_cool and java_is_cool}")\nprint(f"secret_value and python_is_cool: {secret_value and python_is_cool}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Python and java are both cool: False\nsecret_value and python_is_cool: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
print(f"Python or java is cool: {python_is_cool or java_is_cool}")\nprint(f"{1 >= 1.1 or 2 < 1.4}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Python or java is cool: True\nFalse\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
print(f"Java is not cool: {not java_is_cool}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Java is not cool: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You can combine multiple statements, execution order is from left to right. You can control the execution order by using brackets.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
print(bool(not java_is_cool or secret_value and python_is_cool or empty_list))\nprint(bool(not (java_is_cool or secret_value and python_is_cool or empty_list)))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
True\nFalse\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

if

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
statement = True\nif statement:\n    print("statement is True")\n\nif not statement:\n    print("statement is not True")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
statement is True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
empty_list = []\n# With if and elif, conversion to `bool` is implicit\nif empty_list:\n    print("empty list will not evaluate to True")  # this won't be executed\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
val = 3\nif 0 <= val < 1 or val == 3:\n    print("Value is positive and less than one or value is three")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Value is positive and less than one or value is three\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

if-else

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
my_dict = {}\nif my_dict:\n    print("there is something in my dict")\nelse:\n    print("my dict is empty :(")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
my dict is empty :(\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

if-elif-else

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
val = 88\nif val >= 100:\n    print("value is equal or greater than 100")\nelif val > 10:\n    print("value is greater than 10 but less than 100")\nelse:\n    print("value is equal or less than 10")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
value is greater than 10 but less than 100\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You can have as many elif statements as you need. In addition, else at the end is not mandatory.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
greeting = "Hello fellow Pythonista!"\nlanguage = "Italian"\n\nif language == "Swedish":\n    greeting = "Hejsan!"\nelif language == "Finnish":\n    greeting = "Latua perkele!"\nelif language == "Spanish":\n    greeting = "Hola!"\nelif language == "German":\n    greeting = "Guten Tag!"\n\nprint(greeting)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Hello fellow Pythonista!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

For more detailed overview about conditionals, check this tutorial from Real Python.

\n\n
\n
\n
\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/04_lists.html", "content": "\n\n\n\n\n04_lists\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

Lists

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
my_empty_list = []\nprint(f"empty list: {my_empty_list}, type: {type(my_empty_list)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
empty list: [], type: <class 'list'>\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
list_of_ints = [1, 2, 6, 7]\nlist_of_misc = [0.2, 5, "Python", "is", "still fun", "!"]\nprint(f"lengths: {len(list_of_ints)} and {len(list_of_misc)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
lengths: 4 and 6\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Accessing values

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
my_list = ["Python", "is", "still", "cool"]\nprint(my_list[0])\nprint(my_list[3])\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Python\ncool\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
coordinates = [[12.0, 13.3], [0.6, 18.0], [88.0, 1.1]]  # two dimensional\nprint(f"first coordinate: {coordinates[0]}")\nprint(f"second element of first coordinate: {coordinates[0][1]}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
first coordinate: [12.0, 13.3]\nsecond element of first coordinate: 13.3\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Updating values

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
my_list = [0, 1, 2, 3, 4, 5]\nmy_list[0] = 99\nprint(my_list)\n\n# remove first value\ndel my_list[0]\nprint(my_list)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
[99, 1, 2, 3, 4, 5]\n[1, 2, 3, 4, 5]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Checking if certain value is present in list

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
languages = ["Java", "C++", "Go", "Python", "JavaScript"]\nif "Python" in languages:\n    print("Python is there!")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Python is there!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
if 6 not in [1, 2, 3, 7]:\n    print("number 6 is not present")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
number 6 is not present\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

List are mutable

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
original = [1, 2, 3]\nmodified = original\nmodified[0] = 99\nprint(f"original: {original}, modified: {modified}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
original: [99, 2, 3], modified: [99, 2, 3]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You can get around this by creating new list:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
original = [1, 2, 3]\nmodified = list(original)  # Note list()\n# Alternatively, you can use copy method\n# modified = original.copy()\nmodified[0] = 99\nprint(f"original: {original}, modified: {modified}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
original: [1, 2, 3], modified: [99, 2, 3]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

list.append()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
my_list = [1]\nmy_list.append("ham")\nprint(my_list)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
[1, 'ham']\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

list.remove()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
my_list = ["Python", "is", "sometimes", "fun"]\nmy_list.remove("sometimes")\nprint(my_list)\n\n# If you are not sure that the value is in list, better to check first:\nif "Java" in my_list:\n    my_list.remove("Java")\nelse:\n    print("Java is not part of this story.")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
['Python', 'is', 'fun']\nJava is not part of this story.\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

list.sort()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
numbers = [8, 1, 6, 5, 10]\nnumbers.sort()\nprint(f"numbers: {numbers}")\n\nnumbers.sort(reverse=True)\nprint(f"numbers reversed: {numbers}")\n\nwords = ["this", "is", "a", "list", "of", "words"]\nwords.sort()\nprint(f"words: {words}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
numbers: [1, 5, 6, 8, 10]\nnumbers reversed: [10, 8, 6, 5, 1]\nwords: ['a', 'is', 'list', 'of', 'this', 'words']\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

sorted(list)

While list.sort() sorts the list in-place, sorted(list) returns a new list and leaves the original untouched:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
numbers = [8, 1, 6, 5, 10]\nsorted_numbers = sorted(numbers)\nprint(f"{numbers=}, {sorted_numbers=}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
numbers=[8, 1, 6, 5, 10], sorted_numbers=[1, 5, 6, 8, 10]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

list.extend()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
first_list = ["beef", "ham"]\nsecond_list = ["potatoes", 1, 3]\nfirst_list.extend(second_list)\nprint(f"{first_list=}, {second_list=}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
first_list=['beef', 'ham', 'potatoes', 1, 3], second_list=['potatoes', 1, 3]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Alternatively you can also extend lists by summing them:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
first = [1, 2, 3]\nsecond = [4, 5]\nfirst += second  # same as: first = first + second\nprint(f"{first=}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
first=[1, 2, 3, 4, 5]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

list.reverse()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [16]:
\n
\n
\n
my_list = ["a", "b", "ham"]\nmy_list.reverse()\nprint(my_list)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
['ham', 'b', 'a']\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/05_dictionaries.html", "content": "\n\n\n\n\n05_dictionaries\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

Dictionaries

Collections of key-value pairs.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
my_empty_dict = {}  # alternative: my_empty_dict = dict()\nprint(f"dict: {my_empty_dict}, type: {type(my_empty_dict)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
dict: {}, type: <class 'dict'>\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Initialization

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
dict1 = {"value1": 1.6, "value2": 10, "name": "John Doe"}\ndict2 = dict(value1=1.6, value2=10, name="John Doe")\n\nprint(dict1)\nprint(dict2)\n\nprint(f"equals: {dict1 == dict2}")\nprint(f"length: {len(dict1)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'value1': 1.6, 'value2': 10, 'name': 'John Doe'}\n{'value1': 1.6, 'value2': 10, 'name': 'John Doe'}\nequals: True\nlength: 3\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

dict.keys(), dict.values(), dict.items()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
print(f"keys: {dict1.keys()}")\nprint(f"values: {dict1.values()}")\nprint(f"items: {dict1.items()}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
keys: dict_keys(['value1', 'value2', 'name'])\nvalues: dict_values([1.6, 10, 'John Doe'])\nitems: dict_items([('value1', 1.6), ('value2', 10), ('name', 'John Doe')])\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Accessing and setting values

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
my_dict = {}\nmy_dict["key1"] = "value1"\nmy_dict["key2"] = 99\nmy_dict["key1"] = "new value"  # overriding existing value\nprint(my_dict)\nprint(f"value of key1: {my_dict['key1']}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'key1': 'new value', 'key2': 99}\nvalue of key1: new value\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Accessing a nonexistent key will raise KeyError (see dict.get() for workaround):

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
# print(my_dict['nope'])\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Deleting

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
my_dict = {"key1": "value1", "key2": 99, "keyX": "valueX"}\ndel my_dict["keyX"]\nprint(my_dict)\n\n# Usually better to make sure that the key exists (see also pop() and popitem())\nkey_to_delete = "my_key"\nif key_to_delete in my_dict:\n    del my_dict[key_to_delete]\nelse:\n    print(f"{key_to_delete} is not in {my_dict}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'key1': 'value1', 'key2': 99}\nmy_key is not in {'key1': 'value1', 'key2': 99}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Dictionaries are mutable

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
my_dict = {"ham": "good", "carrot": "semi good"}\nmy_other_dict = my_dict\nmy_other_dict["carrot"] = "super tasty"\nmy_other_dict["sausage"] = "best ever"\nprint(f"{my_dict=}\\nother: {my_other_dict}")\nprint(f"equals: {my_dict == my_other_dict}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
my_dict={'ham': 'good', 'carrot': 'super tasty', 'sausage': 'best ever'}\nother: {'ham': 'good', 'carrot': 'super tasty', 'sausage': 'best ever'}\nequals: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Create a new dict if you want to have a copy:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
my_dict = {"ham": "good", "carrot": "semi good"}\nmy_other_dict = dict(my_dict)\nmy_other_dict["beer"] = "decent"\nprint(f"{my_dict=}\\nother: {my_other_dict}")\nprint(f"equals: {my_dict == my_other_dict}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
my_dict={'ham': 'good', 'carrot': 'semi good'}\nother: {'ham': 'good', 'carrot': 'semi good', 'beer': 'decent'}\nequals: False\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

\n

dict.get()

Returns None if key is not in dict. However, you can also specify default return value which will be returned if key is not present in the dict.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
my_dict = {"a": 1, "b": 2, "c": 3}\nvalue_of_d = my_dict.get("d")\nprint(f"d: {value_of_d}")\n\nvalue_of_d = my_dict.get("d", "my default value")\nprint(f"d: {value_of_d}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
d: None\nd: my default value\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

dict.pop()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
my_dict = dict(food="ham", drink="beer", sport="football")\nprint(f"dict before pops: {my_dict}")\n\nfood = my_dict.pop("food")\nprint(f"food: {food}")\nprint(f"dict after popping food: {my_dict}")\n\nfood_again = my_dict.pop("food", "default value for food")\nprint(f"food again: {food_again}")\nprint(f"dict after popping food again: {my_dict}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
dict before pops: {'food': 'ham', 'drink': 'beer', 'sport': 'football'}\nfood: ham\ndict after popping food: {'drink': 'beer', 'sport': 'football'}\nfood again: default value for food\ndict after popping food again: {'drink': 'beer', 'sport': 'football'}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

dict.setdefault()

Returns the value of key defined as first parameter. If the key is not present in the dict, adds key with default value (second parameter).

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
my_dict = {"a": 1, "b": 2, "c": 3}\na = my_dict.setdefault("a", "my default value")\nd = my_dict.setdefault("d", "my default value")\nprint(f"a: {a}\\nd: {d}\\nmy_dict: {my_dict}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
a: 1\nd: my default value\nmy_dict: {'a': 1, 'b': 2, 'c': 3, 'd': 'my default value'}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

dict.update()

Merge two dicts

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
dict1 = {"a": 1, "b": 2}\ndict2 = {"c": 3}\ndict1.update(dict2)\nprint(dict1)\n\n# If they have same keys:\ndict1.update({"c": 4})\nprint(dict1)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'a': 1, 'b': 2, 'c': 3}\n{'a': 1, 'b': 2, 'c': 4}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

The keys of a dict have to be immutable

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Thus you can not use e.g. a list or a dict as key because they are mutable types\n:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
# bad_dict = {['my_list'], 'value'}  # Raises TypeError\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Values can be mutable

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
good_dict = {"my key": ["Python", "is", "still", "cool"]}\nprint(good_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'my key': ['Python', 'is', 'still', 'cool']}\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/06_for_loops.html", "content": "\n\n\n\n\n06_for_loops\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

for loops

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Looping lists

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
my_list = [1, 2, 3, 4, "Python", "is", "neat"]\nfor item in my_list:\n    print(item)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
1\n2\n3\n4\nPython\nis\nneat\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

break

Stop the execution of the loop.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
for item in my_list:\n    if item == "Python":\n        break\n    print(item)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
1\n2\n3\n4\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

continue

Continue to the next item without executing the lines occuring after continue inside the loop.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
for item in my_list:\n    if item == 1:\n        continue\n    print(item)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
2\n3\n4\nPython\nis\nneat\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

enumerate()

In case you need to also know the index:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
for idx, val in enumerate(my_list):\n    print(f"idx: {idx}, value: {val}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
idx: 0, value: 1\nidx: 1, value: 2\nidx: 2, value: 3\nidx: 3, value: 4\nidx: 4, value: Python\nidx: 5, value: is\nidx: 6, value: neat\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Looping dictionaries

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
my_dict = {"hacker": True, "age": 72, "name": "John Doe"}\nfor val in my_dict:\n    print(val)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
hacker\nage\nname\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
for key, val in my_dict.items():\n    print(f"{key}={val}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
hacker=True\nage=72\nname=John Doe\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

range()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
for number in range(5):\n    print(number)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0\n1\n2\n3\n4\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
for number in range(2, 5):\n    print(number)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
2\n3\n4\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
for number in range(0, 10, 2):  # last one is step\n    print(number)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0\n2\n4\n6\n8\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/07_functions.html", "content": "\n\n\n\n\n07_functions\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

Functions

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
def my_first_function():\n    print("Hello world!")\n\n\nprint(f"type: {type(my_first_function)}")\n\nmy_first_function()  # Calling a function\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
type: <class 'function'>\nHello world!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Arguments

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
def greet_us(name1, name2):\n    print(f"Hello {name1} and {name2}!")\n\n\ngreet_us("John Doe", "Superman")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Hello John Doe and Superman!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
# Function with return value\ndef strip_and_lowercase(original):\n    modified = original.strip().lower()\n    return modified\n\n\nuggly_string = "  MixED CaSe "\npretty = strip_and_lowercase(uggly_string)\nprint(f"pretty: {pretty}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
pretty: mixed case\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Keyword arguments

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
def my_fancy_calculation(first, second, third):\n    return first + second - third\n\n\nprint(my_fancy_calculation(3, 2, 1))\n\nprint(my_fancy_calculation(first=3, second=2, third=1))\n\n# With keyword arguments you can mix the order\nprint(my_fancy_calculation(third=1, first=3, second=2))\n\n# You can mix arguments and keyword arguments but you have to start with arguments\nprint(my_fancy_calculation(3, third=1, second=2))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
4\n4\n4\n4\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Default arguments

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
def create_person_info(name, age, job=None, salary=300):\n    info = {"name": name, "age": age, "salary": salary}\n\n    # Add 'job' key only if it's provided as parameter\n    if job:\n        info.update(dict(job=job))\n\n    return info\n\n\nperson1 = create_person_info("John Doe", 82)  # use default values for job and salary\nperson2 = create_person_info("Lisa Doe", 22, "hacker", 10000)\nprint(person1)\nprint(person2)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'name': 'John Doe', 'age': 82, 'salary': 300}\n{'name': 'Lisa Doe', 'age': 22, 'salary': 10000, 'job': 'hacker'}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't use mutable objects as default arguments!

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
def append_if_multiple_of_five(number, magical_list=[]):\n    if number % 5 == 0:\n        magical_list.append(number)\n    return magical_list\n\n\nprint(append_if_multiple_of_five(100))\nprint(append_if_multiple_of_five(105))\nprint(append_if_multiple_of_five(123))\nprint(append_if_multiple_of_five(123, []))\nprint(append_if_multiple_of_five(123))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
[100]\n[100, 105]\n[100, 105]\n[]\n[100, 105]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Here's how you can achieve desired behavior:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
def append_if_multiple_of_five(number, magical_list=None):\n    if not magical_list:\n        magical_list = []\n    if number % 5 == 0:\n        magical_list.append(number)\n    return magical_list\n\n\nprint(append_if_multiple_of_five(100))\nprint(append_if_multiple_of_five(105))\nprint(append_if_multiple_of_five(123))\nprint(append_if_multiple_of_five(123, []))\nprint(append_if_multiple_of_five(123))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
[100]\n[105]\n[]\n[]\n[]\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Docstrings

Strings for documenting your functions, methods, modules and variables.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
def print_sum(val1, val2):\n    """Function which prints the sum of given arguments."""\n    print(f"sum: {val1 + val2}")\n\n\nprint(help(print_sum))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Help on function print_sum in module __main__:\n\nprint_sum(val1, val2)\n    Function which prints the sum of given arguments.\n\nNone\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
def calculate_sum(val1, val2):\n    """This is a longer docstring defining also the args and the return value.\n\n    Args:\n        val1: The first parameter.\n        val2: The second parameter.\n\n    Returns:\n        The sum of val1 and val2.\n\n    """\n    return val1 + val2\n\n\nprint(help(calculate_sum))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Help on function calculate_sum in module __main__:\n\ncalculate_sum(val1, val2)\n    This is a longer docstring defining also the args and the return value.\n    \n    Args:\n        val1: The first parameter.\n        val2: The second parameter.\n    \n    Returns:\n        The sum of val1 and val2.\n\nNone\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

pass statement

pass is a statement which does nothing when it's executed. It can be used e.g. a as placeholder to make the code syntatically correct while sketching the functions and/or classes of your application. For example, the following is valid Python.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
def my_function(some_argument):\n    pass\n\n\ndef my_other_function():\n    pass\n
\n\n
\n
\n
\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/08_testing1.html", "content": "\n\n\n\n\n08_testing1\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

Testing with pytest - part 1

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why to write tests?

    \n
  • Who wants to perform manual testing?
    • \n
  • When you fix a bug or add a new feature, tests are a way to verify that you did not break anything on the way
    • \n
  • If you have clear requirements, you can have matching test(s) for each requirement
    • \n
  • You don't have to be afraid of refactoring
    • \n
  • Tests document your implementation - they show other people use cases of your implementation
    • \n
  • This list is endless...
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Test-driven development aka TDD

In short, the basic idea of TDD is to write tests before writing the actual implementation. Maybe the most significant benefit of the approach is that the developer focuses on writing tests which match with what the program should do. Whereas if the tests are written after the actual implementation, there is a high risk for rushing tests which just show green light for the already written logic.

\n

Tests are first class citizens in modern, agile software development, which is why it's important to start thinking TDD early during your Python learning path.

\n

The workflow of TDD can be summarized as follows:

\n
    \n
  1. Add a test case(s) for the change / feature / bug fix you are going to implement
    2. \n
  2. Run all tests and check that the new one fails
    3. \n
  3. Implement required changes
    4. \n
  4. Run tests and verify that all pass
    5. \n
  5. Refactor
    6. \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Running pytest inside notebooks

These are the steps required to run pytest inside Jupyter cells. You can copy the content of this cell to the top of your notebook which contains tests.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
# Let's make sure pytest and ipytest packages are installed\n# ipytest is required for running pytest inside Jupyter notebooks\nimport sys\n\n!{sys.executable} -m pip install pytest\n!{sys.executable} -m pip install ipytest\n\n# These are needed for running pytest inside Jupyter notebooks\nimport ipytest\n\nipytest.autoconfig()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Requirement already satisfied: pytest in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (7.3.1)\r\nRequirement already satisfied: iniconfig in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (2.0.0)\r\nRequirement already satisfied: pluggy<2.0,>=0.12 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (1.0.0)\r\nRequirement already satisfied: packaging in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (23.1)\r\nRequirement already satisfied: tomli>=1.0.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (2.0.1)\r\nRequirement already satisfied: exceptiongroup>=1.0.0rc8 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (1.1.1)\r\n\r\n[notice] A new release of pip available: 22.3.1 -> 23.1.1\r\n[notice] To update, run: pip install --upgrade pip\r\nRequirement already satisfied: ipytest in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (0.13.1)\r\nRequirement already satisfied: packaging in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (23.1)\r\nRequirement already satisfied: ipython in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (8.12.0)\r\nRequirement already satisfied: pytest>=5.4 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (7.3.1)\r\nRequirement already satisfied: pluggy<2.0,>=0.12 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (1.0.0)\r\nRequirement already satisfied: iniconfig in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (2.0.0)\r\nRequirement already satisfied: exceptiongroup>=1.0.0rc8 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (1.1.1)\r\nRequirement already satisfied: tomli>=1.0.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (2.0.1)\r\nRequirement already satisfied: pexpect>4.3 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (4.8.0)\r\nRequirement already satisfied: prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (3.0.38)\r\nRequirement already satisfied: pygments>=2.4.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (2.15.0)\r\nRequirement already satisfied: traitlets>=5 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (5.9.0)\r\nRequirement already satisfied: jedi>=0.16 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.18.2)\r\nRequirement already satisfied: stack-data in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.6.2)\r\nRequirement already satisfied: matplotlib-inline in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.1.6)\r\nRequirement already satisfied: pickleshare in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.7.5)\r\nRequirement already satisfied: decorator in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (5.1.1)\r\nRequirement already satisfied: appnope in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.1.3)\r\nRequirement already satisfied: backcall in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.2.0)\r\nRequirement already satisfied: parso<0.9.0,>=0.8.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from jedi>=0.16->ipython->ipytest) (0.8.3)\r\nRequirement already satisfied: ptyprocess>=0.5 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pexpect>4.3->ipython->ipytest) (0.7.0)\r\nRequirement already satisfied: wcwidth in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30->ipython->ipytest) (0.2.6)\r\nRequirement already satisfied: executing>=1.2.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (1.2.0)\r\nRequirement already satisfied: asttokens>=2.1.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (2.2.1)\r\nRequirement already satisfied: pure-eval in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (0.2.2)\r\nRequirement already satisfied: six in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from asttokens>=2.1.0->stack-data->ipython->ipytest) (1.16.0)\r\n\r\n[notice] A new release of pip available: 22.3.1 -> 23.1.1\r\n[notice] To update, run: pip install --upgrade pip\r\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

pytest test cases

Let's consider we have a function called sum_of_three_numbers for which we want to write a test.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
def sum_of_three_numbers(num1, num2, num3):\n    return num1 + num2 + num3\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Pytest test cases are actually quite similar as you have already seen in the exercises. Most of the exercises are structured like pytest test cases by dividing each exercise into three cells:

\n
    \n
  1. Setup the variables used in the test
    2. \n
  2. Your implementation
    3. \n
  3. Verify that your implementation does what is wanted by using assertions
    4. \n
\n

See the example test case below to see the similarities between the exercises and common structure of test cases.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
%%ipytest\n\ndef test_sum_of_three_numbers():\n    # 1. Setup the variables used in the test\n    num1 = 2\n    num2 = 3\n    num3 = 5\n    \n    # 2. Call the functionality you want to test\n    result = sum_of_three_numbers(num1, num2, num3)\n    \n    # 3. Verify that the outcome is expected\n    assert result == 10\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
.                                                                                            [100%]\n1 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Now go ahead and change the line assert result == 10 such that the assertion fails to see the output of a failed test.

\n\n
\n
\n
\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/10_file_io.html", "content": "\n\n\n\n\n10_file_io\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

File I/O

Reading and writing files.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Working with paths

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
from pathlib import Path\n\ncurrent_file = Path("file_io.ipynb").resolve()\nprint(f"current file: {current_file}")\n# Note: in .py files you can get the path of current file by Path(__file__)\n\ncurrent_dir = current_file.parent\nprint(f"current directory: {current_dir}")\n\ndata_dir = current_dir.parent / "data"\nprint(f"data directory: {data_dir}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
current file: /Users/jerrypussinen/github/jerry-git/learn-python3/notebooks/beginner/notebooks/file_io.ipynb\ncurrent directory: /Users/jerrypussinen/github/jerry-git/learn-python3/notebooks/beginner/notebooks\ndata directory: /Users/jerrypussinen/github/jerry-git/learn-python3/notebooks/beginner/data\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Checking if path exists

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
print(f"exists: {data_dir.exists()}")\nprint(f"is file: {data_dir.is_file()}")\nprint(f"is directory: {data_dir.is_dir()}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
exists: True\nis file: False\nis directory: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Reading files

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
file_path = data_dir / "simple_file.txt"\n\nwith open(file_path) as simple_file:\n    for line in simple_file:\n        print(line.strip())\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
First line\nSecond line\nThird\nAnd so the story goes!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

The with statement is for obtaining a context manager that will be used as an execution context for the commands inside the with. Context managers guarantee that certain operations are done when exiting the context.

\n

In this case, the context manager guarantees that simple_file.close() is implicitly called when exiting the context. This is a way to make developers life easier: you don't have to remember to explicitly close the file you openened nor be worried about an exception occuring while the file is open. Unclosed file maybe a source of a resource leak. Thus, prefer using with open() structure always with file I/O.

\n

To have an example, the same as above without the with.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
file_path = data_dir / "simple_file.txt"\n\n# THIS IS NOT THE PREFERRED WAY\nsimple_file = open(file_path)\nfor line in simple_file:\n    print(line.strip())\nsimple_file.close()  # This has to be called explicitly\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
First line\nSecond line\nThird\nAnd so the story goes!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Writing files

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
new_file_path = data_dir / "new_file.txt"\n\nwith open(new_file_path, "w") as my_file:\n    my_file.write("This is my first file that I wrote with Python.")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Now go and check that there is a new_file.txt in the data directory. After that you can delete the file by:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
if new_file_path.exists():  # make sure it's there\n    new_file_path.unlink()\n
\n\n
\n
\n
\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/11_classes.html", "content": "\n\n\n\n\n11_classes\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

Classes

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
class MyFirstClass:\n    def __init__(self, name):\n        self.name = name\n\n    def greet(self):\n        print(f"Hello {self.name}!")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
my_instance = MyFirstClass("John Doe")\nprint(f"my_instance: {my_instance}")\nprint(f"type: {type(my_instance)}")\nprint(f"my_instance.name: {my_instance.name}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
my_instance: <__main__.MyFirstClass object at 0x10d893220>\ntype: <class '__main__.MyFirstClass'>\nmy_instance.name: John Doe\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Methods

The functions inside classes are called methods. They are used similarly as functions.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
alice = MyFirstClass(name="Alice")\nalice.greet()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Hello Alice!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

__init__()

__init__() is a special method that is used for initialising instances of the class. It's called when you create an instance of the class.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
class Example:\n    def __init__(self):\n        print("Now we are inside __init__")\n\n\nprint("creating instance of Example")\nexample = Example()\nprint("instance created")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
creating instance of Example\nNow we are inside __init__\ninstance created\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

__init__() is typically used for initialising instance variables of your class. These can be listed as arguments after self. To be able to access these instance variables later during your instance's lifetime, you have to save them into self. self is the first argument of the methods of your class and it's your access to the instance variables and other methods.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
class Example:\n    def __init__(self, var1, var2):\n        self.first_var = var1\n        self.second_var = var2\n\n    def print_variables(self):\n        print(f"{self.first_var} {self.second_var}")\n\n\ne = Example("abc", 123)\ne.print_variables()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
abc 123\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

__str__()

__str__() is a special method which is called when an instance of the class is converted to string (e.g. when you want to print the instance). In other words, by defining __str__ method for your class, you can decide what's the printable version of the instances of your class. The method should return a string.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
class Person:\n    def __init__(self, name, age):\n        self.name = name\n        self.age = age\n\n    def __str__(self):\n        return f"Person: {self.name}"\n\n\njack = Person("Jack", 82)\nprint(f"This is the string presentation of jack: {jack}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
This is the string presentation of jack: Person: Jack\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Class variables vs instance variables

Class variables are shared between all the instances of that class whereas instance variables can hold different values between different instances of that class.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
class Example:\n    # These are class variables\n    name = "Example class"\n    description = "Just an example of a simple class"\n\n    def __init__(self, var1):\n        # This is an instance variable\n        self.instance_variable = var1\n\n    def show_info(self):\n        info = f"instance_variable: {self.instance_variable}, name: {Example.name}, description: {Example.description}"\n        print(info)\n\n\ninst1 = Example("foo")\ninst2 = Example("bar")\n\n# name and description have identical values between instances\nassert inst1.name == inst2.name == Example.name\nassert inst1.description == inst2.description == Example.description\n\n# If you change the value of a class variable, it's changed across all instances\nExample.name = "Modified name"\ninst1.show_info()\ninst2.show_info()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
instance_variable: foo, name: Modified name, description: Just an example of a simple class\ninstance_variable: bar, name: Modified name, description: Just an example of a simple class\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Public vs private

In python there's now strict separation for private/public methods or instance variables. The convention is to start the name of the method or instance variable with underscore if it should be treated as private. Private means that it should not be accessed from outside of the class.

\n

For example, let's consider that we have a Person class which has age as an instance variable. We want that age is not directly accessed (e.g. changed) after the instance is created. In Python, this would be:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
class Person:\n    def __init__(self, age):\n        self._age = age\n\n\nexample_person = Person(age=15)\n# You can't do this:\n# print(example_person.age)\n# Nor this:\n# example_person.age = 16\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

If you want the age to be readable but not writable, you can use property:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
class Person:\n    def __init__(self, age):\n        self._age = age\n\n    @property\n    def age(self):\n        return self._age\n\n\nexample_person = Person(age=15)\n# Now you can do this:\nprint(example_person.age)\n# But not this:\n# example_person.age = 16\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
15\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This way you can have a controlled access to the instance variables of your class:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
class Person:\n    def __init__(self, age):\n        self._age = age\n\n    @property\n    def age(self):\n        return self._age\n\n    def celebrate_birthday(self):\n        self._age += 1\n        print(f"Happy bday for {self._age} years old!")\n\n\nexample_person = Person(age=15)\nexample_person.celebrate_birthday()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Happy bday for 16 years old!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Introduction to inheritance

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
class Animal:\n    def greet(self):\n        print("Hello, I am an animal")\n\n    @property\n    def favorite_food(self):\n        return "beef"\n\n\nclass Dog(Animal):\n    def greet(self):\n        print("wof wof")\n\n\nclass Cat(Animal):\n    @property\n    def favorite_food(self):\n        return "fish"\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
dog = Dog()\ndog.greet()\nprint(f"Dog's favorite food is {dog.favorite_food}")\n\ncat = Cat()\ncat.greet()\nprint(f"Cat's favorite food is {cat.favorite_food}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
wof wof\nDog's favorite food is beef\nHello, I am an animal\nCat's favorite food is fish\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/12_exceptions.html", "content": "\n\n\n\n\n12_exceptions\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

Exceptions

When something goes wrong an exception is raised. For example, if you try to divide by zero, ZeroDivisionError is raised or if you try to access a nonexistent key in a dictionary, KeyError is raised.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
empty_dict = {}\n# empty_dict['key']  # Uncomment to see the traceback\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

try-except structure

If you know that a block of code can fail in some manner, you can use try-except structure to handle potential exceptions in a desired way.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
# Let's try to open a file that does not exist\nfile_name = "not_existing.txt"\n\ntry:\n    with open(file_name) as my_file:\n        print("File is successfully open")\n\nexcept FileNotFoundError as e:\n    print(f"Uups, file: {file_name} not found")\n    print(f"Exception: {e} was raised")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Uups, file: not_existing.txt not found\nException: [Errno 2] No such file or directory: 'not_existing.txt' was raised\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

If you don't know the type of exceptions that a code block can possibly raise, you can use Exception which catches all exceptions. In addition, you can have multiple except statements.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
def calculate_division(var1, var2):\n    result = 0\n\n    try:\n        result = var1 / var2\n    except ZeroDivisionError as ex1:\n        print("Can't divide by zero")\n    except Exception as ex2:\n        print(f"Exception: {ex2}")\n\n    return result\n\n\nresult1 = calculate_division(3, 3)\nprint(f"result1: {result1}")\n\nresult2 = calculate_division(3, "3")\nprint(f"result2: {result2}")\n\nresult3 = calculate_division(3, 0)\nprint(f"result3: {result3}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
result1: 1.0\nException: unsupported operand type(s) for /: 'int' and 'str'\nresult2: 0\nCan't divide by zero\nresult3: 0\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

try-except can be also in outer scope:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
def calculate_division(var1, var2):\n    return var1 / var2\n\n\ntry:\n    result = calculate_division(3, "3")\nexcept Exception as e:\n    print(e)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
unsupported operand type(s) for /: 'int' and 'str'\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Creating your custom exceptions

In your own applications, you can use custom exceptions for signaling users about errors which occur during your application run time.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
import math\n\n\n# Define your own exception\nclass NegativeNumbersNotSupported(Exception):\n    pass\n\n\n# Dummy example how to use your custom exception\ndef secret_calculation(number1, number2):\n    if number1 < 0 or number2 < 0:\n        msg = f"Negative number in at least one of the parameters: {number1}, {number2}"\n        raise NegativeNumbersNotSupported(msg)\n\n    return math.sqrt(number1) + math.sqrt(number2)\n\n\n# Uncomment to see the traceback\n# result = secret_calculation(-1, 1)\n
\n\n
\n
\n
\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/13_modules_and_packages.html", "content": "\n\n\n\n\n13_modules_and_packages\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

Modules and packages

\n

Module is a Python source code file, i.e. a file with .py extension.

\n
\n
\n

Package is a directory which contains __init__.py file and can contain python modules and other packages.

\n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why to organize your code into modules and packages

    \n
  • Maintainability
    • \n
  • Reusability
    • \n
  • Namespacing
    • \n
  • People unfamiliar with your project can get a clear overview just by looking at the directory structure of your project
    • \n
  • Searching for certain functionality or class is easy
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

How to use

Let's use the following directory structure as an example:

\n
food_store/\n    __init__.py\n\n    product/\n        __init__.py\n\n        fruit/\n            __init__.py\n            apple.py\n            banana.py\n\n        drink/\n            __init__.py\n            juice.py\n            milk.py\n            beer.py\n\n    cashier/\n        __ini__.py\n        receipt.py\n        calculator.py\n
\n

Let's consider that banana.py file contains:

\n
def get_available_brands():\n    return ["chiquita"]\n\n\nclass Banana:\n    def __init__(self, brand="chiquita"):\n        if brand not in get_available_brands():\n            raise ValueError(f"Unknown brand: {brand}")\n        self._brand = brand\n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Importing

Let's say that we need access Banana class from banana.py file inside receipt.py. We can achive this by importing at the beginning of receipt.py:

\n
from food_store.product.fruit.banana import Banana\n\n# then it's used like this\nmy_banana = Banana()\n
\n

If we need to access multiple classes or functions from banana.py file:

\n
from food_store.product.fruit import banana\n\n# then it's used like this\nbrands = banana.get_available_brands()\nmy_banana = banana.Banana()\n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

A comprehensive introduction to modules and packages can be found here.

\n\n
\n
\n
\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/14_debugging.html", "content": "\n\n\n\n\n14_debugging\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

Debugging with pdb

Your program does not always behave how you would expect it to behave. If the origin of the mistake is unclear, debugging is usually the most effective to find the root cause of the unexpected behavior. The Python Standard Library has a built-in debugger which is a powerful tool for solving any issues related to your code.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

breakpoint()

The basic use case for debugging is that you want to stop the execution of your program at some certain point and monitor variable values or program execution in general from that specific point onward. You stop the execution at the point you want by setting a breakpoint into code by breakpoint().

\n

When you execute your program, the execution will stop at this point and will enter to interactive debugger session. You can add as many breakpoints into your code as you want.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Useful commands

See the full list here.

\n
    \n
  • h or help: Prints a list of available commands. If you give an argument, e.g. help continue, prints help of the continue command.
    • \n
  • l or list: List a piece of code around the current position.
    • \n
  • n or next: Execute next line.
    • \n
  • s or step: Same as next but "steps into" the function called in the next line.
    • \n
  • c or continue: Continue execution until next breakpoint.
    • \n
  • r or return: Continue execution until the return of current function.
    • \n
  • q or quit: Quit debugger and abort program execution.
    • \n
\n

Note that you can see the value of any variable by typing the variable name during the debugging session. You can also execute arbitrary code during the debugging session.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Let's see how it works

Uncomment the Pdb().set_trace() (this is the Jupyter notebook equivalent for breakpoint()) lines and execute the cell. Execute the program line by line by using the commands defined above. Try all the above mentioned commands at least once. Pay attention to the difference between n and s.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
from IPython.core.debugger import Pdb\n\n\nclass SuperGreeter:\n    def __init__(self, people_to_greet):\n        self.people = people_to_greet\n\n    def greet(self):\n        for person in self.people:\n            if person.islower():\n                self._greet_street_style(person)\n            elif len(person) > 7:\n                self._greet_hawaii(person)\n            else:\n                self._greet_polite(person)\n\n    def _greet_polite(self, name):\n        greeting = f"G'day {name}! How are you doing?"\n        print(greeting)\n\n    def _greet_street_style(self, name):\n        # Pdb().set_trace() # UNCOMMENT\n        name = name.upper()\n        print(f"WASSUP {name}!?")\n\n    def _greet_hawaii(self, name):\n        print(f"Aloha {name}!")\n\n\ndef main():\n    people = ["John Doe", "Donald", "Lisa", "alex"]\n    # Pdb().set_trace()  # UNCOMMENT\n    greeter = SuperGreeter(people)\n    greeter.greet()\n\n\nmain()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Aloha John Doe!\nG'day Donald! How are you doing?\nG'day Lisa! How are you doing?\nWASSUP ALEX!?\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/15_std_lib.html", "content": "\n\n\n\n\n15_std_lib\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

Goodies of the Python Standard Library

The Python Standard Libary is part of your Python installation. It contains a wide range of packages which may be helpful while building your Python masterpieces. This notebook lists some of the commonly used packages and their main functionalities.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

datetime for working with dates and times

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
import datetime as dt\n\nlocal_now = dt.datetime.now()\nprint(f"local now: {local_now}")\n\nutc_now = dt.datetime.utcnow()\nprint(f"utc now: {utc_now}")\n\n# You can access any value separately:\nprint(\n    f"{local_now.year} {local_now.month} {local_now.day} {local_now.hour} {local_now.minute} {local_now.second}"\n)\n\nprint(f"date: {local_now.date()}")\nprint(f"time: {local_now.time()}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
local now: 2023-04-24 13:19:22.350525\nutc now: 2023-04-24 10:19:22.350692\n2023 4 24 13 19 22\ndate: 2023-04-24\ntime: 13:19:22.350525\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

strftime()

For string formatting the datetime

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
formatted1 = local_now.strftime("%Y/%m/%d-%H:%M:%S")\nprint(formatted1)\n\nformatted2 = local_now.strftime("date: %Y-%m-%d time:%H:%M:%S")\nprint(formatted2)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
2023/04/24-13:19:22\ndate: 2023-04-24 time:13:19:22\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

strptime()

For converting a datetime string into a datetime object

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
my_dt = dt.datetime.strptime("2000-01-01 10:00:00", "%Y-%m-%d %H:%M:%S")\nprint(f"my_dt: {my_dt}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
my_dt: 2000-01-01 10:00:00\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

timedelta

For working with time difference.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
tomorrow = local_now + dt.timedelta(days=1)\nprint(f"tomorrow this time: {tomorrow}")\n\ndelta = tomorrow - local_now\nprint(f"tomorrow - now = {delta}")\nprint(f"days: {delta.days}, seconds: {delta.seconds}")\nprint(f"total seconds: {delta.total_seconds()}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
tomorrow this time: 2023-04-25 13:19:22.350525\ntomorrow - now = 1 day, 0:00:00\ndays: 1, seconds: 0\ntotal seconds: 86400.0\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Working with timezones

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
import datetime as dt\nfrom zoneinfo import ZoneInfo\n\nnaive_utc_now = dt.datetime.utcnow()\nprint(f"naive utc now: {naive_utc_now}, tzinfo: {naive_utc_now.tzinfo}")\n\n# Localizing naive datetimes\nUTC_TZ = ZoneInfo("UTC")\nutc_now = naive_utc_now.replace(tzinfo=UTC_TZ)\nprint(f"utc now: {utc_now}, tzinfo: {utc_now.tzinfo}")\n\n# Converting localized datetimes to different timezone\nPARIS_TZ = ZoneInfo("Europe/Paris")\nparis_now = utc_now.astimezone(PARIS_TZ)\nprint(f"Paris: {paris_now}, tzinfo: {paris_now.tzinfo}")\n\nNEW_YORK_TZ = ZoneInfo("America/New_York")\nny_now = utc_now.astimezone(NEW_YORK_TZ)\nprint(f"New York: {ny_now}, tzinfo: {ny_now.tzinfo}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
naive utc now: 2023-04-24 10:19:22.431004, tzinfo: None\nutc now: 2023-04-24 10:19:22.431004+00:00, tzinfo: UTC\nParis: 2023-04-24 12:19:22.431004+02:00, tzinfo: Europe/Paris\nNew York: 2023-04-24 06:19:22.431004-04:00, tzinfo: America/New_York\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

NOTE: If your project uses datetimes heavily, you may want to take a look at external libraries, such as Pendulum and Maya, which make working with datetimes easier for certain use cases.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

logging

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
import logging\n\n# Handy way for getting a dedicated logger for every module separately\nlogger = logging.getLogger(__name__)\nlogger.setLevel(logging.WARNING)\n\nlogger.debug("This is debug")\nlogger.info("This is info")\nlogger.warning("This is warning")\nlogger.error("This is error")\nlogger.critical("This is critical")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
This is warning\nThis is error\nThis is critical\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Logging expections

There's a neat exception function in logging module which will automatically log the stack trace in addition to user defined log entry.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
try:\n    path_calculation = 1 / 0\nexcept ZeroDivisionError:\n    logging.exception("All went south in my calculation")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
ERROR:root:All went south in my calculation\nTraceback (most recent call last):\n  File "/var/folders/q4/_vnp7m_d625g5prgrz28h_fr0000gn/T/ipykernel_59325/3366486048.py", line 2, in <module>\n    path_calculation = 1 / 0\nZeroDivisionError: division by zero\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Formatting log entries

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
import logging\n\n# This is only required for Jupyter notebook environment\nfrom importlib import reload\n\nreload(logging)\n\nmy_format = "%(asctime)s | %(name)-12s | %(levelname)-10s | %(message)s"\nlogging.basicConfig(format=my_format)\n\nlogger = logging.getLogger("MyLogger")\n\nlogger.warning("Something bad is going to happen")\nlogger.error("Uups, it already happened")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
2023-04-24 13:19:22,459 | MyLogger     | WARNING    | Something bad is going to happen\n2023-04-24 13:19:22,460 | MyLogger     | ERROR      | Uups, it already happened\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Logging to a file

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
import logging\nfrom pathlib import Path\n\n# This is only required for Jupyter notebook environment\nfrom importlib import reload\n\nreload(logging)\n\nlogger = logging.getLogger("MyFileLogger")\n\n# Let's define a file_handler for our logger\nlog_path = Path.cwd() / "my_log.txt"\nfile_handler = logging.FileHandler(log_path)\n\n# And a nice format\nformatter = logging.Formatter(\n    "%(asctime)s | %(name)-12s | %(levelname)-10s | %(message)s"\n)\nfile_handler.setFormatter(formatter)\n\nlogger.addHandler(file_handler)\n\n# If you want to see it also in the console, add another handler for it\n# logger.addHandler(logging.StreamHandler())\n\nlogger.warning("Oops something is going to happen")\nlogger.error("John Doe visits our place")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

random for random number generation

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
import random\n\nrand_int = random.randint(1, 100)\nprint(f"random integer between 1-100: {rand_int}")\n\nrand = random.random()\nprint(f"random float between 0-1: {rand}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
random integer between 1-100: 22\nrandom float between 0-1: 0.010400736609471939\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

If you need pseudo random numbers, you can set the seed for random. This will reproduce the output (try running the cell multiple times):

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
import random\n\nrandom.seed(5)  # Setting the seed\n\n# Let's print 10 random numbers\nfor _ in range(10):\n    print(random.random())\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0.6229016948897019\n0.7417869892607294\n0.7951935655656966\n0.9424502837770503\n0.7398985747399307\n0.922324996665417\n0.029005228283614737\n0.46562265437810535\n0.9433567169983137\n0.6489745531369242\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

re for regular expressions

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Searching occurences

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
import re\n\nsecret_code = "qwret 8sfg12f5 fd09f_df"\n# "r" at the beginning means raw format, use it with regular expression patterns\nsearch_pattern = r"(g12)"\n\nmatch = re.search(search_pattern, secret_code)\nprint(f"match: {match}")\nprint(f"match.group(): {match.group()}")\n\nnumbers_pattern = r"[0-9]"\nnumbers_match = re.findall(numbers_pattern, secret_code)\nprint(f"numbers: {numbers_match}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
match: <re.Match object; span=(9, 12), match='g12'>\nmatch.group(): g12\nnumbers: ['8', '1', '2', '5', '0', '9']\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Variable validation

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
import re\n\n\ndef validate_only_lower_case_letters(to_validate):\n    pattern = r"^[a-z]+$"\n    return bool(re.match(pattern, to_validate))\n\n\nprint(validate_only_lower_case_letters("thisshouldbeok"))\nprint(validate_only_lower_case_letters("thisshould notbeok"))\nprint(validate_only_lower_case_letters("Thisshouldnotbeok"))\nprint(validate_only_lower_case_letters("thisshouldnotbeok1"))\nprint(validate_only_lower_case_letters(""))\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
True\nFalse\nFalse\nFalse\nFalse\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/16_testing2.html", "content": "\n\n\n\n\n16_testing2\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

Testing with pytest - part 2

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
# Let's make sure pytest and ipytest packages are installed\n# ipytest is required for running pytest inside Jupyter notebooks\nimport sys\n\n!{sys.executable} -m pip install pytest\n!{sys.executable} -m pip install ipytest\n\n# These are needed for running pytest inside Jupyter notebooks\nimport ipytest\n\nipytest.autoconfig()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Requirement already satisfied: pytest in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (7.3.1)\r\nRequirement already satisfied: exceptiongroup>=1.0.0rc8 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (1.1.1)\r\nRequirement already satisfied: tomli>=1.0.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (2.0.1)\r\nRequirement already satisfied: pluggy<2.0,>=0.12 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (1.0.0)\r\nRequirement already satisfied: iniconfig in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (2.0.0)\r\nRequirement already satisfied: packaging in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (23.1)\r\n\r\n[notice] A new release of pip available: 22.3.1 -> 23.1.1\r\n[notice] To update, run: pip install --upgrade pip\r\nRequirement already satisfied: ipytest in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (0.13.1)\r\nRequirement already satisfied: pytest>=5.4 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (7.3.1)\r\nRequirement already satisfied: ipython in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (8.12.0)\r\nRequirement already satisfied: packaging in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (23.1)\r\nRequirement already satisfied: exceptiongroup>=1.0.0rc8 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (1.1.1)\r\nRequirement already satisfied: tomli>=1.0.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (2.0.1)\r\nRequirement already satisfied: pluggy<2.0,>=0.12 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (1.0.0)\r\nRequirement already satisfied: iniconfig in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (2.0.0)\r\nRequirement already satisfied: pexpect>4.3 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (4.8.0)\r\nRequirement already satisfied: pygments>=2.4.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (2.15.0)\r\nRequirement already satisfied: jedi>=0.16 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.18.2)\r\nRequirement already satisfied: prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (3.0.38)\r\nRequirement already satisfied: traitlets>=5 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (5.9.0)\r\nRequirement already satisfied: pickleshare in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.7.5)\r\nRequirement already satisfied: backcall in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.2.0)\r\nRequirement already satisfied: stack-data in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.6.2)\r\nRequirement already satisfied: matplotlib-inline in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.1.6)\r\nRequirement already satisfied: decorator in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (5.1.1)\r\nRequirement already satisfied: appnope in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.1.3)\r\nRequirement already satisfied: parso<0.9.0,>=0.8.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from jedi>=0.16->ipython->ipytest) (0.8.3)\r\nRequirement already satisfied: ptyprocess>=0.5 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pexpect>4.3->ipython->ipytest) (0.7.0)\r\nRequirement already satisfied: wcwidth in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30->ipython->ipytest) (0.2.6)\r\nRequirement already satisfied: asttokens>=2.1.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (2.2.1)\r\nRequirement already satisfied: executing>=1.2.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (1.2.0)\r\nRequirement already satisfied: pure-eval in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (0.2.2)\r\nRequirement already satisfied: six in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from asttokens>=2.1.0->stack-data->ipython->ipytest) (1.16.0)\r\n\r\n[notice] A new release of pip available: 22.3.1 -> 23.1.1\r\n[notice] To update, run: pip install --upgrade pip\r\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

@pytest.fixture

Let's consider we have an implemention of Person class which we want to test.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
class Person:\n    def __init__(self, first_name, last_name, age):\n        self.first_name = first_name\n        self.last_name = last_name\n        self.age = age\n\n    @property\n    def full_name(self):\n        return f"{self.first_name} {self.last_name}"\n\n    @property\n    def as_dict(self):\n        return {"name": self.full_name, "age": self.age}\n\n    def increase_age(self, years):\n        if years < 0:\n            raise ValueError("Can not make people younger :(")\n        self.age += years\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You can easily create resusable testing code by using pytest fixtures. If you introduce your fixtures inside conftest.py, the fixtures are available for all your test cases. In general, the location of conftest.py is at the root of your tests directory.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
import pytest\n\n\n@pytest.fixture()\ndef default_person():\n    person = Person(first_name="John", last_name="Doe", age=82)\n    return person\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Then you can utilize default_person fixture in the actual test cases.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
%%ipytest\n\n\ndef test_full_name(default_person): # Note: we use fixture as an argument of the test case\n    result = default_person.full_name\n    assert result == 'John Doe'\n    \n    \ndef test_as_dict(default_person):\n    expected = {'name': 'John Doe', 'age': 82}\n    result = default_person.as_dict\n    assert result == expected\n    \n    \ndef test_increase_age(default_person):\n    default_person.increase_age(1)\n    assert default_person.age == 83\n    \n    default_person.increase_age(10)\n    assert default_person.age == 93\n    \n    \ndef test_increase_age_with_negative_number(default_person):\n    with pytest.raises(ValueError):\n        default_person.increase_age(-1)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
....                                                                                         [100%]\n4 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

By using a fixture, we could use the same default_person for all our four test cases!

\n

In the test_increase_age_with_negative_number we used pytest.raises to verify that an exception is raised.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

@pytest.mark.parametrize

Sometimes you want to test the same functionality with multiple different inputs. pytest.mark.parametrize is your solution for defining multiple different inputs with expected outputs. Let's consider the following implementation of replace_names function.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
def replace_names(original_str, new_name):\n    """Replaces names (uppercase words) of original_str by new_name"""\n    words = original_str.split()\n    manipulated_words = [new_name if w.istitle() else w for w in words]\n    return " ".join(manipulated_words)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

We can test the replace_names function with multiple inputs by using pytest.mark.parametrize.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
%%ipytest\n\n\n@pytest.mark.parametrize("original,new_name,expected", [\n        ('this is Lisa', 'John Doe', 'this is John Doe'),\n        ('how about Frank and Amy', 'John', 'how about John and John'),\n        ('no names here', 'John Doe', 'no names here'),\n    ])\ndef test_replace_names(original, new_name, expected):\n    result = replace_names(original, new_name)\n    assert result == expected\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
...                                                                                          [100%]\n3 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/17_venv.html", "content": "\n\n\n\n\n17_venv\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

Virtual environment

When working with Python projects, best practice is to have a separate virtual environment for each of them.

\n

Each virtual environment has its own Python binary. When you install some Python package into your virtual environment, it'll be installed only into that specific environment. This means that you can have different versions of a single Python package in different virtual environments in the same machine. Virtual environments are also useful if you need to use different Python versions in your projects.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

venv

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Creating new virtual environment

You can create all your virtual environments into a single directory (for example, .virtualenvs directory inside your home folder). This makes them easier to find.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

python3 -m venv /path/to/new/environment

\n

or

\n

path/to/your/python -m venv /path/to/new/environment

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Activating the virtual environment

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Windows: path_to_virtual_env\\Scripts\\activate.bat
\nPosix: source path_to_virtual_env/bin/activate

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Installing packages

After activating the newly created virtual environment, you can install new packages by using pip. For example if you want to install pytest:

\n

python -m pip install pytest

\n

it'll be installed into path_to_virtual_env/lib/<python_version>/site-packages. Note that the path to site-packages maybe slightly different depending on the operating system you are using.

\n

You can list the installed packages and their versions by running:

\n

python -m pip freeze

\n\n
\n
\n
\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/html/18_project_structure.html", "content": "\n\n\n\n\n18_project_structure\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

Project structure

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Python script

Python is a great language for building small helper tools for various different kinds of tasks. Such small tools can be often expressed as a single file Python script.

\n

Here is an example structure for a Python script (aka executable Python module).

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
# the content of my_script.py\n\n# imports\nimport logging\n\n# constants\nLOGGER = logging.getLogger()\n\n\ndef magical_function():\n    LOGGER.warning("We are about to do some magical stuff")\n\n\ndef main():\n    # The actual logic of the script\n    magical_function()\n\n\nif __name__ == "__main__":\n    main()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
We are about to do some magical stuff\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Python package

An example structure for a python project:

\n
my_project/\n    README.md\n    requirements.txt\n    setup.py\n\n    src/\n        my_project/\n            __init__.py\n            my_module.py\n            other_module.py\n\n            my_pkg1/\n                __init__.py\n                my_third_module.py\n\n    tests/\n        conftest.py\n        test_module.py\n        test_other_module.py\n\n        my_pkg1/\n            test_my_third_module.py\n\n
\n
    \n
  • requirements.txt lists the Python packages from which my_project depends on.
      \n
    • these can be installed by running pip install -r requirements
      • \n
    \n
    • \n
  • setup.py is a file in which you include relevant information about your project and the file is also used for packaging your project. Here's a minimal example of a setup.py:
    • \n
\n
'''Minimal setup.py file'''\n\nfrom setuptools import setup, find_packages\n\nsetup(\n    name='my_project',\n    version='0.1',\n    packages=find_packages(where="src"),\n    package_dir={"": "src"})\n
\n
    \n
  • Once you have the setup.py file in place, you can install your project in editable mode by running pip install -e . in the root directory of your project. In editable mode the installed version is updated when you make changes to the source code files.
    • \n
\n\n
\n
\n
\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/beginner/notebooks/01_strings.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [Strings](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_string = \\\"Python is my favorite programming language!\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_string\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"type(my_string)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"len(my_string)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Respecting [PEP8](https://www.python.org/dev/peps/pep-0008/#maximum-line-length) with long strings\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"long_story = (\\n\",\n \" \\\"Lorem ipsum dolor sit amet, consectetur adipiscing elit.\\\"\\n\",\n \" \\\"Pellentesque eget tincidunt felis. Ut ac vestibulum est.\\\"\\n\",\n \" \\\"In sed ipsum sit amet sapien scelerisque bibendum. Sed \\\"\\n\",\n \" \\\"sagittis purus eu diam fermentum pellentesque.\\\"\\n\",\n \")\\n\",\n \"long_story\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `str.replace()`\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If you don't know how it works, you can always check the `help`:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"help(str.replace)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"This will not modify `my_string` because replace is not done in-place.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_string.replace(\\\"a\\\", \\\"?\\\")\\n\",\n \"print(my_string)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"You have to store the return value of `replace` instead.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_modified_string = my_string.replace(\\\"is\\\", \\\"will be\\\")\\n\",\n \"print(my_modified_string)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## f-strings\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"first_name = \\\"John\\\"\\n\",\n \"last_name = \\\"Doe\\\"\\n\",\n \"age = 88\\n\",\n \"print(f\\\"My name is {first_name} {last_name}, you can call me {first_name}.\\\")\\n\",\n \"print(f\\\"I'm {age} years old.\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"Use '=' to also print the variable name like this: {age=}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `str.join()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"pandas = \\\"pandas\\\"\\n\",\n \"numpy = \\\"numpy\\\"\\n\",\n \"requests = \\\"requests\\\"\\n\",\n \"cool_python_libs = \\\", \\\".join([pandas, numpy, requests])\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"Some cool python libraries: {cool_python_libs}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Alternative (not as [Pythonic](http://docs.python-guide.org/en/latest/writing/style/#idioms) and [slower](https://waymoot.org/home/python_string/)):\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"cool_python_libs = pandas + \\\", \\\" + numpy + \\\", \\\" + requests\\n\",\n \"print(f\\\"Some cool python libraries: {cool_python_libs}\\\")\\n\",\n \"\\n\",\n \"cool_python_libs = pandas\\n\",\n \"cool_python_libs += \\\", \\\" + numpy\\n\",\n \"cool_python_libs += \\\", \\\" + requests\\n\",\n \"print(f\\\"Some cool python libraries: {cool_python_libs}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `str.upper(), str.lower(), str.title()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"mixed_case = \\\"PyTHoN hackER\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"mixed_case.upper()\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"mixed_case.lower()\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"mixed_case.title()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `str.strip()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"ugly_formatted = \\\" \\\\n \\\\t Some story to tell \\\"\\n\",\n \"stripped = ugly_formatted.strip()\\n\",\n \"\\n\",\n \"print(f\\\"ugly: {ugly_formatted}\\\")\\n\",\n \"print(f\\\"stripped: {stripped}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `str.split()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"sentence = \\\"three different words\\\"\\n\",\n \"words = sentence.split()\\n\",\n \"print(words)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"type(words)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"secret_binary_data = \\\"01001,101101,11100000\\\"\\n\",\n \"binaries = secret_binary_data.split(\\\",\\\")\\n\",\n \"print(binaries)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Calling multiple methods in a row\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"ugly_mixed_case = \\\" ThIS LooKs BAd \\\"\\n\",\n \"pretty = ugly_mixed_case.strip().lower().replace(\\\"bad\\\", \\\"good\\\")\\n\",\n \"print(pretty)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Note that execution order is from left to right. Thus, this won't work:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"pretty = ugly_mixed_case.replace(\\\"bad\\\", \\\"good\\\").strip().lower()\\n\",\n \"print(pretty)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [Escape characters](http://python-reference.readthedocs.io/en/latest/docs/str/escapes.html#escape-characters)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"two_lines = \\\"First line\\\\nSecond line\\\"\\n\",\n \"print(two_lines)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"indented = \\\"\\\\tThis will be indented\\\"\\n\",\n \"print(indented)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 1\n}\n" }, { "path": "notebooks/beginner/notebooks/02_numbers.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [Numbers](https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-complex)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `int`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_int = 6\\n\",\n \"print(f\\\"value: {my_int}, type: {type(my_int)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `float`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_float = float(my_int)\\n\",\n \"print(f\\\"value: {my_float}, type: {type(my_float)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Note that division of `int`s produces `float`:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(1 / 1)\\n\",\n \"print(6 / 5)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Be aware of the binary floating-point pitfalls (see [Decimal](#decimal) for workaround):\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"val = 0.1 + 0.1 + 0.1\\n\",\n \"print(val == 0.3)\\n\",\n \"print(val)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Floor division `//`, modulus `%`, power `**`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"7 // 5\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"7 % 5\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"2**3\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"\\n\",\n \"## [`decimal.Decimal`](https://docs.python.org/3/library/decimal.html)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from decimal import Decimal\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from_float = Decimal(0.1)\\n\",\n \"from_str = Decimal(\\\"0.1\\\")\\n\",\n \"print(f\\\"from float: {from_float}\\\\nfrom string: {from_str}\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_decimal = Decimal(\\\"0.1\\\")\\n\",\n \"sum_of_decimals = my_decimal + my_decimal + my_decimal\\n\",\n \"print(sum_of_decimals == Decimal(\\\"0.3\\\"))\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Operator precedence in calculations\\n\",\n \"Mathematical operator precedence applies. Use brackets if you want to change the execution order:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(1 + 2**2 * 3 / 6) # 1 + 4 * 3 / 6 == 1 + 12 / 6 == 1 + 2\\n\",\n \"print((1 + 2**2) * 3 / 6)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/03_conditionals.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Conditionals\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Testing truth value\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `bool`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"type of True and False: {type(True)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"0: {bool(0)}, 1: {bool(1)}\\\")\\n\",\n \"print(f\\\"empty list: {bool([])}, list with values: {bool(['woop'])}\\\")\\n\",\n \"print(f\\\"empty dict: {bool({})}, dict with values: {bool({'Python': 'cool'})}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `==, !=, >, <, >=, <=`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"{1 == 0}\\\")\\n\",\n \"print(f\\\"{1 != 0}\\\")\\n\",\n \"print(f\\\"{1 > 0}\\\")\\n\",\n \"print(f\\\"{1 > 1}\\\")\\n\",\n \"print(f\\\"{1 < 0}\\\")\\n\",\n \"print(f\\\"{1 < 1}\\\")\\n\",\n \"print(f\\\"{1 >= 0}\\\")\\n\",\n \"print(f\\\"{1 >= 1}\\\")\\n\",\n \"print(f\\\"{1 <= 0}\\\")\\n\",\n \"print(f\\\"{1 <= 1}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"You can combine these:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"{1 <= 2 <= 3}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `and, or, not`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"python_is_cool = True\\n\",\n \"java_is_cool = False\\n\",\n \"empty_list = []\\n\",\n \"secret_value = 3.14\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"Python and java are both cool: {python_is_cool and java_is_cool}\\\")\\n\",\n \"print(f\\\"secret_value and python_is_cool: {secret_value and python_is_cool}\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"Python or java is cool: {python_is_cool or java_is_cool}\\\")\\n\",\n \"print(f\\\"{1 >= 1.1 or 2 < 1.4}\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"Java is not cool: {not java_is_cool}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"You can combine multiple statements, execution order is from left to right. You can control the execution order by using brackets.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(bool(not java_is_cool or secret_value and python_is_cool or empty_list))\\n\",\n \"print(bool(not (java_is_cool or secret_value and python_is_cool or empty_list)))\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `if`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"statement = True\\n\",\n \"if statement:\\n\",\n \" print(\\\"statement is True\\\")\\n\",\n \"\\n\",\n \"if not statement:\\n\",\n \" print(\\\"statement is not True\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"empty_list = []\\n\",\n \"# With if and elif, conversion to `bool` is implicit\\n\",\n \"if empty_list:\\n\",\n \" print(\\\"empty list will not evaluate to True\\\") # this won't be executed\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"val = 3\\n\",\n \"if 0 <= val < 1 or val == 3:\\n\",\n \" print(\\\"Value is positive and less than one or value is three\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `if-else`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {}\\n\",\n \"if my_dict:\\n\",\n \" print(\\\"there is something in my dict\\\")\\n\",\n \"else:\\n\",\n \" print(\\\"my dict is empty :(\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `if-elif-else`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"val = 88\\n\",\n \"if val >= 100:\\n\",\n \" print(\\\"value is equal or greater than 100\\\")\\n\",\n \"elif val > 10:\\n\",\n \" print(\\\"value is greater than 10 but less than 100\\\")\\n\",\n \"else:\\n\",\n \" print(\\\"value is equal or less than 10\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"You can have as many `elif` statements as you need. In addition, `else` at the end is not mandatory.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"greeting = \\\"Hello fellow Pythonista!\\\"\\n\",\n \"language = \\\"Italian\\\"\\n\",\n \"\\n\",\n \"if language == \\\"Swedish\\\":\\n\",\n \" greeting = \\\"Hejsan!\\\"\\n\",\n \"elif language == \\\"Finnish\\\":\\n\",\n \" greeting = \\\"Latua perkele!\\\"\\n\",\n \"elif language == \\\"Spanish\\\":\\n\",\n \" greeting = \\\"Hola!\\\"\\n\",\n \"elif language == \\\"German\\\":\\n\",\n \" greeting = \\\"Guten Tag!\\\"\\n\",\n \"\\n\",\n \"print(greeting)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"For more detailed overview about conditionals, check this [tutorial from Real Python](https://realpython.com/python-conditional-statements/).\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 1\n}\n" }, { "path": "notebooks/beginner/notebooks/04_lists.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [Lists](https://docs.python.org/3/library/stdtypes.html#lists)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_empty_list = []\\n\",\n \"print(f\\\"empty list: {my_empty_list}, type: {type(my_empty_list)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"list_of_ints = [1, 2, 6, 7]\\n\",\n \"list_of_misc = [0.2, 5, \\\"Python\\\", \\\"is\\\", \\\"still fun\\\", \\\"!\\\"]\\n\",\n \"print(f\\\"lengths: {len(list_of_ints)} and {len(list_of_misc)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Accessing values\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_list = [\\\"Python\\\", \\\"is\\\", \\\"still\\\", \\\"cool\\\"]\\n\",\n \"print(my_list[0])\\n\",\n \"print(my_list[3])\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"coordinates = [[12.0, 13.3], [0.6, 18.0], [88.0, 1.1]] # two dimensional\\n\",\n \"print(f\\\"first coordinate: {coordinates[0]}\\\")\\n\",\n \"print(f\\\"second element of first coordinate: {coordinates[0][1]}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Updating values\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_list = [0, 1, 2, 3, 4, 5]\\n\",\n \"my_list[0] = 99\\n\",\n \"print(my_list)\\n\",\n \"\\n\",\n \"# remove first value\\n\",\n \"del my_list[0]\\n\",\n \"print(my_list)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Checking if certain value is present in list\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"languages = [\\\"Java\\\", \\\"C++\\\", \\\"Go\\\", \\\"Python\\\", \\\"JavaScript\\\"]\\n\",\n \"if \\\"Python\\\" in languages:\\n\",\n \" print(\\\"Python is there!\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if 6 not in [1, 2, 3, 7]:\\n\",\n \" print(\\\"number 6 is not present\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## List are mutable\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"original = [1, 2, 3]\\n\",\n \"modified = original\\n\",\n \"modified[0] = 99\\n\",\n \"print(f\\\"original: {original}, modified: {modified}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"You can get around this by creating new `list`:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"original = [1, 2, 3]\\n\",\n \"modified = list(original) # Note list()\\n\",\n \"# Alternatively, you can use copy method\\n\",\n \"# modified = original.copy()\\n\",\n \"modified[0] = 99\\n\",\n \"print(f\\\"original: {original}, modified: {modified}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `list.append()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_list = [1]\\n\",\n \"my_list.append(\\\"ham\\\")\\n\",\n \"print(my_list)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `list.remove()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_list = [\\\"Python\\\", \\\"is\\\", \\\"sometimes\\\", \\\"fun\\\"]\\n\",\n \"my_list.remove(\\\"sometimes\\\")\\n\",\n \"print(my_list)\\n\",\n \"\\n\",\n \"# If you are not sure that the value is in list, better to check first:\\n\",\n \"if \\\"Java\\\" in my_list:\\n\",\n \" my_list.remove(\\\"Java\\\")\\n\",\n \"else:\\n\",\n \" print(\\\"Java is not part of this story.\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `list.sort()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"numbers = [8, 1, 6, 5, 10]\\n\",\n \"numbers.sort()\\n\",\n \"print(f\\\"numbers: {numbers}\\\")\\n\",\n \"\\n\",\n \"numbers.sort(reverse=True)\\n\",\n \"print(f\\\"numbers reversed: {numbers}\\\")\\n\",\n \"\\n\",\n \"words = [\\\"this\\\", \\\"is\\\", \\\"a\\\", \\\"list\\\", \\\"of\\\", \\\"words\\\"]\\n\",\n \"words.sort()\\n\",\n \"print(f\\\"words: {words}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `sorted(list)`\\n\",\n \"While `list.sort()` sorts the list in-place, `sorted(list)` returns a new list and leaves the original untouched:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"numbers = [8, 1, 6, 5, 10]\\n\",\n \"sorted_numbers = sorted(numbers)\\n\",\n \"print(f\\\"{numbers=}, {sorted_numbers=}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `list.extend()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"first_list = [\\\"beef\\\", \\\"ham\\\"]\\n\",\n \"second_list = [\\\"potatoes\\\", 1, 3]\\n\",\n \"first_list.extend(second_list)\\n\",\n \"print(f\\\"{first_list=}, {second_list=}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Alternatively you can also extend lists by summing them:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"first = [1, 2, 3]\\n\",\n \"second = [4, 5]\\n\",\n \"first += second # same as: first = first + second\\n\",\n \"print(f\\\"{first=}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `list.reverse()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_list = [\\\"a\\\", \\\"b\\\", \\\"ham\\\"]\\n\",\n \"my_list.reverse()\\n\",\n \"print(my_list)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/05_dictionaries.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [Dictionaries](https://docs.python.org/3/library/stdtypes.html#dict) \\n\",\n \"Collections of `key`-`value` pairs. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_empty_dict = {} # alternative: my_empty_dict = dict()\\n\",\n \"print(f\\\"dict: {my_empty_dict}, type: {type(my_empty_dict)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Initialization\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"dict1 = {\\\"value1\\\": 1.6, \\\"value2\\\": 10, \\\"name\\\": \\\"John Doe\\\"}\\n\",\n \"dict2 = dict(value1=1.6, value2=10, name=\\\"John Doe\\\")\\n\",\n \"\\n\",\n \"print(dict1)\\n\",\n \"print(dict2)\\n\",\n \"\\n\",\n \"print(f\\\"equals: {dict1 == dict2}\\\")\\n\",\n \"print(f\\\"length: {len(dict1)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `dict.keys(), dict.values(), dict.items()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"keys: {dict1.keys()}\\\")\\n\",\n \"print(f\\\"values: {dict1.values()}\\\")\\n\",\n \"print(f\\\"items: {dict1.items()}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Accessing and setting values\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {}\\n\",\n \"my_dict[\\\"key1\\\"] = \\\"value1\\\"\\n\",\n \"my_dict[\\\"key2\\\"] = 99\\n\",\n \"my_dict[\\\"key1\\\"] = \\\"new value\\\" # overriding existing value\\n\",\n \"print(my_dict)\\n\",\n \"print(f\\\"value of key1: {my_dict['key1']}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Accessing a nonexistent key will raise `KeyError` (see [`dict.get()`](#dict_get) for workaround):\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# print(my_dict['nope'])\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Deleting\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"key1\\\": \\\"value1\\\", \\\"key2\\\": 99, \\\"keyX\\\": \\\"valueX\\\"}\\n\",\n \"del my_dict[\\\"keyX\\\"]\\n\",\n \"print(my_dict)\\n\",\n \"\\n\",\n \"# Usually better to make sure that the key exists (see also pop() and popitem())\\n\",\n \"key_to_delete = \\\"my_key\\\"\\n\",\n \"if key_to_delete in my_dict:\\n\",\n \" del my_dict[key_to_delete]\\n\",\n \"else:\\n\",\n \" print(f\\\"{key_to_delete} is not in {my_dict}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Dictionaries are mutable\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"ham\\\": \\\"good\\\", \\\"carrot\\\": \\\"semi good\\\"}\\n\",\n \"my_other_dict = my_dict\\n\",\n \"my_other_dict[\\\"carrot\\\"] = \\\"super tasty\\\"\\n\",\n \"my_other_dict[\\\"sausage\\\"] = \\\"best ever\\\"\\n\",\n \"print(f\\\"{my_dict=}\\\\nother: {my_other_dict}\\\")\\n\",\n \"print(f\\\"equals: {my_dict == my_other_dict}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Create a new `dict` if you want to have a copy:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"ham\\\": \\\"good\\\", \\\"carrot\\\": \\\"semi good\\\"}\\n\",\n \"my_other_dict = dict(my_dict)\\n\",\n \"my_other_dict[\\\"beer\\\"] = \\\"decent\\\"\\n\",\n \"print(f\\\"{my_dict=}\\\\nother: {my_other_dict}\\\")\\n\",\n \"print(f\\\"equals: {my_dict == my_other_dict}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"\\n\",\n \"## `dict.get()`\\n\",\n \"Returns `None` if `key` is not in `dict`. However, you can also specify `default` return value which will be returned if `key` is not present in the `dict`. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"a\\\": 1, \\\"b\\\": 2, \\\"c\\\": 3}\\n\",\n \"value_of_d = my_dict.get(\\\"d\\\")\\n\",\n \"print(f\\\"d: {value_of_d}\\\")\\n\",\n \"\\n\",\n \"value_of_d = my_dict.get(\\\"d\\\", \\\"my default value\\\")\\n\",\n \"print(f\\\"d: {value_of_d}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `dict.pop()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = dict(food=\\\"ham\\\", drink=\\\"beer\\\", sport=\\\"football\\\")\\n\",\n \"print(f\\\"dict before pops: {my_dict}\\\")\\n\",\n \"\\n\",\n \"food = my_dict.pop(\\\"food\\\")\\n\",\n \"print(f\\\"food: {food}\\\")\\n\",\n \"print(f\\\"dict after popping food: {my_dict}\\\")\\n\",\n \"\\n\",\n \"food_again = my_dict.pop(\\\"food\\\", \\\"default value for food\\\")\\n\",\n \"print(f\\\"food again: {food_again}\\\")\\n\",\n \"print(f\\\"dict after popping food again: {my_dict}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `dict.setdefault()`\\n\",\n \"Returns the `value` of `key` defined as first parameter. If the `key` is not present in the dict, adds `key` with default value (second parameter).\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"a\\\": 1, \\\"b\\\": 2, \\\"c\\\": 3}\\n\",\n \"a = my_dict.setdefault(\\\"a\\\", \\\"my default value\\\")\\n\",\n \"d = my_dict.setdefault(\\\"d\\\", \\\"my default value\\\")\\n\",\n \"print(f\\\"a: {a}\\\\nd: {d}\\\\nmy_dict: {my_dict}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `dict.update()`\\n\",\n \"Merge two `dict`s\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"dict1 = {\\\"a\\\": 1, \\\"b\\\": 2}\\n\",\n \"dict2 = {\\\"c\\\": 3}\\n\",\n \"dict1.update(dict2)\\n\",\n \"print(dict1)\\n\",\n \"\\n\",\n \"# If they have same keys:\\n\",\n \"dict1.update({\\\"c\\\": 4})\\n\",\n \"print(dict1)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## The keys of a `dict` have to be immutable\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Thus you can not use e.g. a `list` or a `dict` as key because they are mutable types\\n\",\n \":\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# bad_dict = {['my_list'], 'value'} # Raises TypeError\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Values can be mutable\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"good_dict = {\\\"my key\\\": [\\\"Python\\\", \\\"is\\\", \\\"still\\\", \\\"cool\\\"]}\\n\",\n \"print(good_dict)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/06_for_loops.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [`for` loops](https://docs.python.org/3/tutorial/controlflow.html#for-statements)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Looping lists\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_list = [1, 2, 3, 4, \\\"Python\\\", \\\"is\\\", \\\"neat\\\"]\\n\",\n \"for item in my_list:\\n\",\n \" print(item)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `break`\\n\",\n \"Stop the execution of the loop.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for item in my_list:\\n\",\n \" if item == \\\"Python\\\":\\n\",\n \" break\\n\",\n \" print(item)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `continue`\\n\",\n \"Continue to the next item without executing the lines occuring after `continue` inside the loop.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for item in my_list:\\n\",\n \" if item == 1:\\n\",\n \" continue\\n\",\n \" print(item)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `enumerate()`\\n\",\n \"In case you need to also know the index:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for idx, val in enumerate(my_list):\\n\",\n \" print(f\\\"idx: {idx}, value: {val}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Looping dictionaries\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"hacker\\\": True, \\\"age\\\": 72, \\\"name\\\": \\\"John Doe\\\"}\\n\",\n \"for val in my_dict:\\n\",\n \" print(val)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for key, val in my_dict.items():\\n\",\n \" print(f\\\"{key}={val}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `range()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for number in range(5):\\n\",\n \" print(number)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for number in range(2, 5):\\n\",\n \" print(number)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for number in range(0, 10, 2): # last one is step\\n\",\n \" print(number)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/07_functions.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Functions\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def my_first_function():\\n\",\n \" print(\\\"Hello world!\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"print(f\\\"type: {type(my_first_function)}\\\")\\n\",\n \"\\n\",\n \"my_first_function() # Calling a function\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Arguments\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def greet_us(name1, name2):\\n\",\n \" print(f\\\"Hello {name1} and {name2}!\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"greet_us(\\\"John Doe\\\", \\\"Superman\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Function with return value\\n\",\n \"def strip_and_lowercase(original):\\n\",\n \" modified = original.strip().lower()\\n\",\n \" return modified\\n\",\n \"\\n\",\n \"\\n\",\n \"uggly_string = \\\" MixED CaSe \\\"\\n\",\n \"pretty = strip_and_lowercase(uggly_string)\\n\",\n \"print(f\\\"pretty: {pretty}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Keyword arguments\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def my_fancy_calculation(first, second, third):\\n\",\n \" return first + second - third\\n\",\n \"\\n\",\n \"\\n\",\n \"print(my_fancy_calculation(3, 2, 1))\\n\",\n \"\\n\",\n \"print(my_fancy_calculation(first=3, second=2, third=1))\\n\",\n \"\\n\",\n \"# With keyword arguments you can mix the order\\n\",\n \"print(my_fancy_calculation(third=1, first=3, second=2))\\n\",\n \"\\n\",\n \"# You can mix arguments and keyword arguments but you have to start with arguments\\n\",\n \"print(my_fancy_calculation(3, third=1, second=2))\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Default arguments\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def create_person_info(name, age, job=None, salary=300):\\n\",\n \" info = {\\\"name\\\": name, \\\"age\\\": age, \\\"salary\\\": salary}\\n\",\n \"\\n\",\n \" # Add 'job' key only if it's provided as parameter\\n\",\n \" if job:\\n\",\n \" info.update(dict(job=job))\\n\",\n \"\\n\",\n \" return info\\n\",\n \"\\n\",\n \"\\n\",\n \"person1 = create_person_info(\\\"John Doe\\\", 82) # use default values for job and salary\\n\",\n \"person2 = create_person_info(\\\"Lisa Doe\\\", 22, \\\"hacker\\\", 10000)\\n\",\n \"print(person1)\\n\",\n \"print(person2)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"**Don't use mutable objects as default arguments!**\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def append_if_multiple_of_five(number, magical_list=[]):\\n\",\n \" if number % 5 == 0:\\n\",\n \" magical_list.append(number)\\n\",\n \" return magical_list\\n\",\n \"\\n\",\n \"\\n\",\n \"print(append_if_multiple_of_five(100))\\n\",\n \"print(append_if_multiple_of_five(105))\\n\",\n \"print(append_if_multiple_of_five(123))\\n\",\n \"print(append_if_multiple_of_five(123, []))\\n\",\n \"print(append_if_multiple_of_five(123))\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Here's how you can achieve desired behavior:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def append_if_multiple_of_five(number, magical_list=None):\\n\",\n \" if not magical_list:\\n\",\n \" magical_list = []\\n\",\n \" if number % 5 == 0:\\n\",\n \" magical_list.append(number)\\n\",\n \" return magical_list\\n\",\n \"\\n\",\n \"\\n\",\n \"print(append_if_multiple_of_five(100))\\n\",\n \"print(append_if_multiple_of_five(105))\\n\",\n \"print(append_if_multiple_of_five(123))\\n\",\n \"print(append_if_multiple_of_five(123, []))\\n\",\n \"print(append_if_multiple_of_five(123))\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Docstrings\\n\",\n \"Strings for documenting your functions, methods, modules and variables.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def print_sum(val1, val2):\\n\",\n \" \\\"\\\"\\\"Function which prints the sum of given arguments.\\\"\\\"\\\"\\n\",\n \" print(f\\\"sum: {val1 + val2}\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"print(help(print_sum))\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def calculate_sum(val1, val2):\\n\",\n \" \\\"\\\"\\\"This is a longer docstring defining also the args and the return value.\\n\",\n \"\\n\",\n \" Args:\\n\",\n \" val1: The first parameter.\\n\",\n \" val2: The second parameter.\\n\",\n \"\\n\",\n \" Returns:\\n\",\n \" The sum of val1 and val2.\\n\",\n \"\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" return val1 + val2\\n\",\n \"\\n\",\n \"\\n\",\n \"print(help(calculate_sum))\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`pass`](https://docs.python.org/3/reference/simple_stmts.html#the-pass-statement) statement\\n\",\n \"`pass` is a statement which does nothing when it's executed. It can be used e.g. a as placeholder to make the code syntatically correct while sketching the functions and/or classes of your application. For example, the following is valid Python. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def my_function(some_argument):\\n\",\n \" pass\\n\",\n \"\\n\",\n \"\\n\",\n \"def my_other_function():\\n\",\n \" pass\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/08_testing1.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Testing with [pytest](https://docs.pytest.org/en/latest/) - part 1\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Why to write tests?\\n\",\n \"* Who wants to perform manual testing?\\n\",\n \"* When you fix a bug or add a new feature, tests are a way to verify that you did not break anything on the way\\n\",\n \"* If you have clear requirements, you can have matching test(s) for each requirement\\n\",\n \"* You don't have to be afraid of refactoring\\n\",\n \"* Tests document your implementation - they show other people use cases of your implementation\\n\",\n \"* This list is endless...\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [Test-driven development](https://en.wikipedia.org/wiki/Test-driven_development) aka TDD\\n\",\n \"In short, the basic idea of TDD is to write tests before writing the actual implementation. Maybe the most significant benefit of the approach is that the developer focuses on writing tests which match with what the program should do. Whereas if the tests are written after the actual implementation, there is a high risk for rushing tests which just show green light for the already written logic.\\n\",\n \"\\n\",\n \"Tests are first class citizens in modern, agile software development, which is why it's important to start thinking TDD early during your Python learning path. \\n\",\n \"\\n\",\n \"The workflow of TDD can be summarized as follows:\\n\",\n \"1. Add a test case(s) for the change / feature / bug fix you are going to implement\\n\",\n \"2. Run all tests and check that the new one fails\\n\",\n \"3. Implement required changes\\n\",\n \"4. Run tests and verify that all pass\\n\",\n \"5. Refactor\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Running pytest inside notebooks\\n\",\n \"These are the steps required to run pytest inside Jupyter cells. You can copy the content of this cell to the top of your notebook which contains tests.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Let's make sure pytest and ipytest packages are installed\\n\",\n \"# ipytest is required for running pytest inside Jupyter notebooks\\n\",\n \"import sys\\n\",\n \"\\n\",\n \"!{sys.executable} -m pip install pytest\\n\",\n \"!{sys.executable} -m pip install ipytest\\n\",\n \"\\n\",\n \"# These are needed for running pytest inside Jupyter notebooks\\n\",\n \"import ipytest\\n\",\n \"\\n\",\n \"ipytest.autoconfig()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `pytest` test cases\\n\",\n \"Let's consider we have a function called `sum_of_three_numbers` for which we want to write a test.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def sum_of_three_numbers(num1, num2, num3):\\n\",\n \" return num1 + num2 + num3\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Pytest test cases are actually quite similar as you have already seen in the exercises. Most of the exercises are structured like pytest test cases by dividing each exercise into three cells:\\n\",\n \"1. Setup the variables used in the test\\n\",\n \"2. Your implementation\\n\",\n \"3. Verify that your implementation does what is wanted by using assertions\\n\",\n \"\\n\",\n \"See the example test case below to see the similarities between the exercises and common structure of test cases.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest\\n\",\n \"\\n\",\n \"def test_sum_of_three_numbers():\\n\",\n \" # 1. Setup the variables used in the test\\n\",\n \" num1 = 2\\n\",\n \" num2 = 3\\n\",\n \" num3 = 5\\n\",\n \" \\n\",\n \" # 2. Call the functionality you want to test\\n\",\n \" result = sum_of_three_numbers(num1, num2, num3)\\n\",\n \" \\n\",\n \" # 3. Verify that the outcome is expected\\n\",\n \" assert result == 10\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Now go ahead and change the line `assert result == 10` such that the assertion fails to see the output of a failed test.\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/10_file_io.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [File I/O](https://docs.python.org/3/tutorial/inputoutput.html#reading-and-writing-files)\\n\",\n \"Reading and writing files.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Working with paths\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from pathlib import Path\\n\",\n \"\\n\",\n \"current_file = Path(\\\"file_io.ipynb\\\").resolve()\\n\",\n \"print(f\\\"current file: {current_file}\\\")\\n\",\n \"# Note: in .py files you can get the path of current file by Path(__file__)\\n\",\n \"\\n\",\n \"current_dir = current_file.parent\\n\",\n \"print(f\\\"current directory: {current_dir}\\\")\\n\",\n \"\\n\",\n \"data_dir = current_dir.parent / \\\"data\\\"\\n\",\n \"print(f\\\"data directory: {data_dir}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Checking if path exists\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"print(f\\\"exists: {data_dir.exists()}\\\")\\n\",\n \"print(f\\\"is file: {data_dir.is_file()}\\\")\\n\",\n \"print(f\\\"is directory: {data_dir.is_dir()}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Reading files\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"file_path = data_dir / \\\"simple_file.txt\\\"\\n\",\n \"\\n\",\n \"with open(file_path) as simple_file:\\n\",\n \" for line in simple_file:\\n\",\n \" print(line.strip())\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"The [`with`](https://docs.python.org/3/reference/compound_stmts.html#the-with-statement) statement is for obtaining a [context manager](https://docs.python.org/3/reference/datamodel.html#with-statement-context-managers) that will be used as an execution context for the commands inside the `with`. Context managers guarantee that certain operations are done when exiting the context. \\n\",\n \"\\n\",\n \"In this case, the context manager guarantees that `simple_file.close()` is implicitly called when exiting the context. This is a way to make developers life easier: you don't have to remember to explicitly close the file you openened nor be worried about an exception occuring while the file is open. Unclosed file maybe a source of a resource leak. Thus, prefer using `with open()` structure always with file I/O.\\n\",\n \"\\n\",\n \"To have an example, the same as above without the `with`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"file_path = data_dir / \\\"simple_file.txt\\\"\\n\",\n \"\\n\",\n \"# THIS IS NOT THE PREFERRED WAY\\n\",\n \"simple_file = open(file_path)\\n\",\n \"for line in simple_file:\\n\",\n \" print(line.strip())\\n\",\n \"simple_file.close() # This has to be called explicitly\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Writing files\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"new_file_path = data_dir / \\\"new_file.txt\\\"\\n\",\n \"\\n\",\n \"with open(new_file_path, \\\"w\\\") as my_file:\\n\",\n \" my_file.write(\\\"This is my first file that I wrote with Python.\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Now go and check that there is a new_file.txt in the data directory. After that you can delete the file by:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if new_file_path.exists(): # make sure it's there\\n\",\n \" new_file_path.unlink()\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/11_classes.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [Classes](https://docs.python.org/3/tutorial/classes.html#a-first-look-at-classes)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class MyFirstClass:\\n\",\n \" def __init__(self, name):\\n\",\n \" self.name = name\\n\",\n \"\\n\",\n \" def greet(self):\\n\",\n \" print(f\\\"Hello {self.name}!\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_instance = MyFirstClass(\\\"John Doe\\\")\\n\",\n \"print(f\\\"my_instance: {my_instance}\\\")\\n\",\n \"print(f\\\"type: {type(my_instance)}\\\")\\n\",\n \"print(f\\\"my_instance.name: {my_instance.name}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Methods\\n\",\n \"The functions inside classes are called methods. They are used similarly as functions. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"alice = MyFirstClass(name=\\\"Alice\\\")\\n\",\n \"alice.greet()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `__init__()`\\n\",\n \"`__init__()` is a special method that is used for initialising instances of the class. It's called when you create an instance of the class. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Example:\\n\",\n \" def __init__(self):\\n\",\n \" print(\\\"Now we are inside __init__\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"print(\\\"creating instance of Example\\\")\\n\",\n \"example = Example()\\n\",\n \"print(\\\"instance created\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"`__init__()` is typically used for initialising instance variables of your class. These can be listed as arguments after `self`. To be able to access these instance variables later during your instance's lifetime, you have to save them into `self`. `self` is the first argument of the methods of your class and it's your access to the instance variables and other methods. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Example:\\n\",\n \" def __init__(self, var1, var2):\\n\",\n \" self.first_var = var1\\n\",\n \" self.second_var = var2\\n\",\n \"\\n\",\n \" def print_variables(self):\\n\",\n \" print(f\\\"{self.first_var} {self.second_var}\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"e = Example(\\\"abc\\\", 123)\\n\",\n \"e.print_variables()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `__str__()`\\n\",\n \"`__str__()` is a special method which is called when an instance of the class is converted to string (e.g. when you want to print the instance). In other words, by defining `__str__` method for your class, you can decide what's the printable version of the instances of your class. The method should return a string.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Person:\\n\",\n \" def __init__(self, name, age):\\n\",\n \" self.name = name\\n\",\n \" self.age = age\\n\",\n \"\\n\",\n \" def __str__(self):\\n\",\n \" return f\\\"Person: {self.name}\\\"\\n\",\n \"\\n\",\n \"\\n\",\n \"jack = Person(\\\"Jack\\\", 82)\\n\",\n \"print(f\\\"This is the string presentation of jack: {jack}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Class variables vs instance variables\\n\",\n \"Class variables are shared between all the instances of that class whereas instance variables can hold different values between different instances of that class.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Example:\\n\",\n \" # These are class variables\\n\",\n \" name = \\\"Example class\\\"\\n\",\n \" description = \\\"Just an example of a simple class\\\"\\n\",\n \"\\n\",\n \" def __init__(self, var1):\\n\",\n \" # This is an instance variable\\n\",\n \" self.instance_variable = var1\\n\",\n \"\\n\",\n \" def show_info(self):\\n\",\n \" info = f\\\"instance_variable: {self.instance_variable}, name: {Example.name}, description: {Example.description}\\\"\\n\",\n \" print(info)\\n\",\n \"\\n\",\n \"\\n\",\n \"inst1 = Example(\\\"foo\\\")\\n\",\n \"inst2 = Example(\\\"bar\\\")\\n\",\n \"\\n\",\n \"# name and description have identical values between instances\\n\",\n \"assert inst1.name == inst2.name == Example.name\\n\",\n \"assert inst1.description == inst2.description == Example.description\\n\",\n \"\\n\",\n \"# If you change the value of a class variable, it's changed across all instances\\n\",\n \"Example.name = \\\"Modified name\\\"\\n\",\n \"inst1.show_info()\\n\",\n \"inst2.show_info()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Public vs private\\n\",\n \"In python there's now strict separation for private/public methods or instance variables. The convention is to start the name of the method or instance variable with underscore if it should be treated as private. Private means that it should not be accessed from outside of the class.\\n\",\n \"\\n\",\n \"For example, let's consider that we have a `Person` class which has `age` as an instance variable. We want that `age` is not directly accessed (e.g. changed) after the instance is created. In Python, this would be:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Person:\\n\",\n \" def __init__(self, age):\\n\",\n \" self._age = age\\n\",\n \"\\n\",\n \"\\n\",\n \"example_person = Person(age=15)\\n\",\n \"# You can't do this:\\n\",\n \"# print(example_person.age)\\n\",\n \"# Nor this:\\n\",\n \"# example_person.age = 16\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If you want the `age` to be readable but not writable, you can use `property`:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Person:\\n\",\n \" def __init__(self, age):\\n\",\n \" self._age = age\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def age(self):\\n\",\n \" return self._age\\n\",\n \"\\n\",\n \"\\n\",\n \"example_person = Person(age=15)\\n\",\n \"# Now you can do this:\\n\",\n \"print(example_person.age)\\n\",\n \"# But not this:\\n\",\n \"# example_person.age = 16\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"This way you can have a controlled access to the instance variables of your class: \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Person:\\n\",\n \" def __init__(self, age):\\n\",\n \" self._age = age\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def age(self):\\n\",\n \" return self._age\\n\",\n \"\\n\",\n \" def celebrate_birthday(self):\\n\",\n \" self._age += 1\\n\",\n \" print(f\\\"Happy bday for {self._age} years old!\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"example_person = Person(age=15)\\n\",\n \"example_person.celebrate_birthday()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Introduction to inheritance\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Animal:\\n\",\n \" def greet(self):\\n\",\n \" print(\\\"Hello, I am an animal\\\")\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def favorite_food(self):\\n\",\n \" return \\\"beef\\\"\\n\",\n \"\\n\",\n \"\\n\",\n \"class Dog(Animal):\\n\",\n \" def greet(self):\\n\",\n \" print(\\\"wof wof\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"class Cat(Animal):\\n\",\n \" @property\\n\",\n \" def favorite_food(self):\\n\",\n \" return \\\"fish\\\"\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"dog = Dog()\\n\",\n \"dog.greet()\\n\",\n \"print(f\\\"Dog's favorite food is {dog.favorite_food}\\\")\\n\",\n \"\\n\",\n \"cat = Cat()\\n\",\n \"cat.greet()\\n\",\n \"print(f\\\"Cat's favorite food is {cat.favorite_food}\\\")\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/12_exceptions.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [Exceptions](https://docs.python.org/3/library/exceptions.html#concrete-exceptions)\\n\",\n \"When something goes wrong an exception is raised. For example, if you try to divide by zero, `ZeroDivisionError` is raised or if you try to access a nonexistent key in a dictionary, `KeyError` is raised.\\n\",\n \"\\n\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"empty_dict = {}\\n\",\n \"# empty_dict['key'] # Uncomment to see the traceback\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `try-except` structure \\n\",\n \"If you know that a block of code can fail in some manner, you can use `try-except` structure to handle potential exceptions in a desired way.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Let's try to open a file that does not exist\\n\",\n \"file_name = \\\"not_existing.txt\\\"\\n\",\n \"\\n\",\n \"try:\\n\",\n \" with open(file_name) as my_file:\\n\",\n \" print(\\\"File is successfully open\\\")\\n\",\n \"\\n\",\n \"except FileNotFoundError as e:\\n\",\n \" print(f\\\"Uups, file: {file_name} not found\\\")\\n\",\n \" print(f\\\"Exception: {e} was raised\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If you don't know the type of exceptions that a code block can possibly raise, you can use `Exception` which catches all exceptions. In addition, you can have multiple `except` statements.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def calculate_division(var1, var2):\\n\",\n \" result = 0\\n\",\n \"\\n\",\n \" try:\\n\",\n \" result = var1 / var2\\n\",\n \" except ZeroDivisionError as ex1:\\n\",\n \" print(\\\"Can't divide by zero\\\")\\n\",\n \" except Exception as ex2:\\n\",\n \" print(f\\\"Exception: {ex2}\\\")\\n\",\n \"\\n\",\n \" return result\\n\",\n \"\\n\",\n \"\\n\",\n \"result1 = calculate_division(3, 3)\\n\",\n \"print(f\\\"result1: {result1}\\\")\\n\",\n \"\\n\",\n \"result2 = calculate_division(3, \\\"3\\\")\\n\",\n \"print(f\\\"result2: {result2}\\\")\\n\",\n \"\\n\",\n \"result3 = calculate_division(3, 0)\\n\",\n \"print(f\\\"result3: {result3}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"`try-except` can be also in outer scope:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def calculate_division(var1, var2):\\n\",\n \" return var1 / var2\\n\",\n \"\\n\",\n \"\\n\",\n \"try:\\n\",\n \" result = calculate_division(3, \\\"3\\\")\\n\",\n \"except Exception as e:\\n\",\n \" print(e)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Creating your custom exceptions\\n\",\n \"In your own applications, you can use custom exceptions for signaling users about errors which occur during your application run time. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import math\\n\",\n \"\\n\",\n \"\\n\",\n \"# Define your own exception\\n\",\n \"class NegativeNumbersNotSupported(Exception):\\n\",\n \" pass\\n\",\n \"\\n\",\n \"\\n\",\n \"# Dummy example how to use your custom exception\\n\",\n \"def secret_calculation(number1, number2):\\n\",\n \" if number1 < 0 or number2 < 0:\\n\",\n \" msg = f\\\"Negative number in at least one of the parameters: {number1}, {number2}\\\"\\n\",\n \" raise NegativeNumbersNotSupported(msg)\\n\",\n \"\\n\",\n \" return math.sqrt(number1) + math.sqrt(number2)\\n\",\n \"\\n\",\n \"\\n\",\n \"# Uncomment to see the traceback\\n\",\n \"# result = secret_calculation(-1, 1)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 1\n}\n" }, { "path": "notebooks/beginner/notebooks/13_modules_and_packages.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# [Modules and packages](https://docs.python.org/3/tutorial/modules.html#modules)\\n\",\n \"\\n\",\n \"> Module is a Python source code file, i.e. a file with .py extension.\\n\",\n \"\\n\",\n \"> Package is a directory which contains `__init__.py` file and can contain python modules and other packages. \\n\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Why to organize your code into modules and packages\\n\",\n \"* Maintainability\\n\",\n \"* Reusability\\n\",\n \"* Namespacing\\n\",\n \"* People unfamiliar with your project can get a clear overview just by looking at the directory structure of your project\\n\",\n \"* Searching for certain functionality or class is easy\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## How to use\\n\",\n \"\\n\",\n \"Let's use the following directory structure as an example:\\n\",\n \"\\n\",\n \" \\n\",\n \"```\\n\",\n \"food_store/\\n\",\n \" __init__.py\\n\",\n \" \\n\",\n \" product/\\n\",\n \" __init__.py\\n\",\n \" \\n\",\n \" fruit/\\n\",\n \" __init__.py\\n\",\n \" apple.py\\n\",\n \" banana.py\\n\",\n \" \\n\",\n \" drink/\\n\",\n \" __init__.py\\n\",\n \" juice.py\\n\",\n \" milk.py\\n\",\n \" beer.py\\n\",\n \"\\n\",\n \" cashier/\\n\",\n \" __ini__.py\\n\",\n \" receipt.py\\n\",\n \" calculator.py\\n\",\n \"```\\n\",\n \"\\n\",\n \"\\n\",\n \"Let's consider that banana.py file contains:\\n\",\n \"\\n\",\n \"```python\\n\",\n \"\\n\",\n \"def get_available_brands():\\n\",\n \" return [\\\"chiquita\\\"]\\n\",\n \"\\n\",\n \"\\n\",\n \"class Banana:\\n\",\n \" def __init__(self, brand=\\\"chiquita\\\"):\\n\",\n \" if brand not in get_available_brands():\\n\",\n \" raise ValueError(f\\\"Unknown brand: {brand}\\\")\\n\",\n \" self._brand = brand\\n\",\n \" \\n\",\n \"```\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Importing\\n\",\n \"\\n\",\n \"Let's say that we need access `Banana` class from banana.py file inside receipt.py. We can achive this by importing at the beginning of receipt.py:\\n\",\n \"\\n\",\n \"```python\\n\",\n \"from food_store.product.fruit.banana import Banana\\n\",\n \"\\n\",\n \"# then it's used like this\\n\",\n \"my_banana = Banana()\\n\",\n \"```\\n\",\n \"\\n\",\n \"\\n\",\n \"\\n\",\n \"If we need to access multiple classes or functions from banana.py file:\\n\",\n \"\\n\",\n \"```python\\n\",\n \"from food_store.product.fruit import banana\\n\",\n \"\\n\",\n \"# then it's used like this\\n\",\n \"brands = banana.get_available_brands()\\n\",\n \"my_banana = banana.Banana()\\n\",\n \"```\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"A comprehensive introduction to modules and packages can be found [here](https://realpython.com/python-modules-packages/).\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/14_debugging.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Debugging with [`pdb`](https://docs.python.org/3/library/pdb.html#module-pdb)\\n\",\n \"Your program does not always behave how you would expect it to behave. If the origin of the mistake is unclear, debugging is usually the most effective to find the root cause of the unexpected behavior. The Python Standard Library has a built-in debugger which is a powerful tool for solving any issues related to your code.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `breakpoint()`\\n\",\n \"The basic use case for debugging is that you want to stop the execution of your program at some certain point and monitor variable values or program execution in general from that specific point onward. You stop the execution at the point you want by setting a breakpoint into code by `breakpoint()`.\\n\",\n \"\\n\",\n \"When you execute your program, the execution will stop at this point and will enter to interactive debugger session. You can add as many breakpoints into your code as you want.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Useful commands\\n\",\n \"See the full list [here](https://docs.python.org/3/library/pdb.html#debugger-commands).\\n\",\n \"\\n\",\n \"* `h` or `help`: Prints a list of available commands. If you give an argument, e.g. `help continue`, prints help of the `continue` command.\\n\",\n \"* `l` or `list`: List a piece of code around the current position.\\n\",\n \"* `n` or `next`: Execute next line.\\n\",\n \"* `s` or `step`: Same as `next` but \\\"steps into\\\" the function called in the next line.\\n\",\n \"* `c` or `continue`: Continue execution until next breakpoint.\\n\",\n \"* `r` or `return`: Continue execution until the return of current function.\\n\",\n \"* `q` or `quit`: Quit debugger and abort program execution.\\n\",\n \"\\n\",\n \"Note that you can see the value of any variable by typing the variable name during the debugging session. You can also execute arbitrary code during the debugging session.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Let's see how it works\\n\",\n \"Uncomment the `Pdb().set_trace()` (this is the Jupyter notebook equivalent for `breakpoint()`) lines and execute the cell. Execute the program line by line by using the commands defined above. Try all the above mentioned commands at least once. Pay attention to the difference between `n` and `s`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from IPython.core.debugger import Pdb\\n\",\n \"\\n\",\n \"\\n\",\n \"class SuperGreeter:\\n\",\n \" def __init__(self, people_to_greet):\\n\",\n \" self.people = people_to_greet\\n\",\n \"\\n\",\n \" def greet(self):\\n\",\n \" for person in self.people:\\n\",\n \" if person.islower():\\n\",\n \" self._greet_street_style(person)\\n\",\n \" elif len(person) > 7:\\n\",\n \" self._greet_hawaii(person)\\n\",\n \" else:\\n\",\n \" self._greet_polite(person)\\n\",\n \"\\n\",\n \" def _greet_polite(self, name):\\n\",\n \" greeting = f\\\"G'day {name}! How are you doing?\\\"\\n\",\n \" print(greeting)\\n\",\n \"\\n\",\n \" def _greet_street_style(self, name):\\n\",\n \" # Pdb().set_trace() # UNCOMMENT\\n\",\n \" name = name.upper()\\n\",\n \" print(f\\\"WASSUP {name}!?\\\")\\n\",\n \"\\n\",\n \" def _greet_hawaii(self, name):\\n\",\n \" print(f\\\"Aloha {name}!\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"def main():\\n\",\n \" people = [\\\"John Doe\\\", \\\"Donald\\\", \\\"Lisa\\\", \\\"alex\\\"]\\n\",\n \" # Pdb().set_trace() # UNCOMMENT\\n\",\n \" greeter = SuperGreeter(people)\\n\",\n \" greeter.greet()\\n\",\n \"\\n\",\n \"\\n\",\n \"main()\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/15_std_lib.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Goodies of the [Python Standard Library](https://docs.python.org/3/library/#the-python-standard-library)\\n\",\n \"The Python Standard Libary is part of your Python installation. It contains a wide range of packages which may be helpful while building your Python masterpieces. This notebook lists some of the commonly used packages and their main functionalities.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`datetime`](https://docs.python.org/3/library/datetime.html#module-datetime) for working with dates and times\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import datetime as dt\\n\",\n \"\\n\",\n \"local_now = dt.datetime.now()\\n\",\n \"print(f\\\"local now: {local_now}\\\")\\n\",\n \"\\n\",\n \"utc_now = dt.datetime.utcnow()\\n\",\n \"print(f\\\"utc now: {utc_now}\\\")\\n\",\n \"\\n\",\n \"# You can access any value separately:\\n\",\n \"print(\\n\",\n \" f\\\"{local_now.year} {local_now.month} {local_now.day} {local_now.hour} {local_now.minute} {local_now.second}\\\"\\n\",\n \")\\n\",\n \"\\n\",\n \"print(f\\\"date: {local_now.date()}\\\")\\n\",\n \"print(f\\\"time: {local_now.time()}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `strftime()`\\n\",\n \"For string formatting the `datetime`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"formatted1 = local_now.strftime(\\\"%Y/%m/%d-%H:%M:%S\\\")\\n\",\n \"print(formatted1)\\n\",\n \"\\n\",\n \"formatted2 = local_now.strftime(\\\"date: %Y-%m-%d time:%H:%M:%S\\\")\\n\",\n \"print(formatted2)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### `strptime()`\\n\",\n \"For converting a datetime string into a `datetime` object \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dt = dt.datetime.strptime(\\\"2000-01-01 10:00:00\\\", \\\"%Y-%m-%d %H:%M:%S\\\")\\n\",\n \"print(f\\\"my_dt: {my_dt}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`timedelta`](https://docs.python.org/3/library/datetime.html#timedelta-objects)\\n\",\n \"For working with time difference.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"tomorrow = local_now + dt.timedelta(days=1)\\n\",\n \"print(f\\\"tomorrow this time: {tomorrow}\\\")\\n\",\n \"\\n\",\n \"delta = tomorrow - local_now\\n\",\n \"print(f\\\"tomorrow - now = {delta}\\\")\\n\",\n \"print(f\\\"days: {delta.days}, seconds: {delta.seconds}\\\")\\n\",\n \"print(f\\\"total seconds: {delta.total_seconds()}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Working with timezones\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import datetime as dt\\n\",\n \"from zoneinfo import ZoneInfo\\n\",\n \"\\n\",\n \"naive_utc_now = dt.datetime.utcnow()\\n\",\n \"print(f\\\"naive utc now: {naive_utc_now}, tzinfo: {naive_utc_now.tzinfo}\\\")\\n\",\n \"\\n\",\n \"# Localizing naive datetimes\\n\",\n \"UTC_TZ = ZoneInfo(\\\"UTC\\\")\\n\",\n \"utc_now = naive_utc_now.replace(tzinfo=UTC_TZ)\\n\",\n \"print(f\\\"utc now: {utc_now}, tzinfo: {utc_now.tzinfo}\\\")\\n\",\n \"\\n\",\n \"# Converting localized datetimes to different timezone\\n\",\n \"PARIS_TZ = ZoneInfo(\\\"Europe/Paris\\\")\\n\",\n \"paris_now = utc_now.astimezone(PARIS_TZ)\\n\",\n \"print(f\\\"Paris: {paris_now}, tzinfo: {paris_now.tzinfo}\\\")\\n\",\n \"\\n\",\n \"NEW_YORK_TZ = ZoneInfo(\\\"America/New_York\\\")\\n\",\n \"ny_now = utc_now.astimezone(NEW_YORK_TZ)\\n\",\n \"print(f\\\"New York: {ny_now}, tzinfo: {ny_now.tzinfo}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"**NOTE**: If your project uses datetimes heavily, you may want to take a look at external libraries, such as [Pendulum](https://pendulum.eustace.io/docs/) and [Maya](https://github.com/kennethreitz/maya), which make working with datetimes easier for certain use cases.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`logging`](https://docs.python.org/3/library/logging.html#module-logging)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import logging\\n\",\n \"\\n\",\n \"# Handy way for getting a dedicated logger for every module separately\\n\",\n \"logger = logging.getLogger(__name__)\\n\",\n \"logger.setLevel(logging.WARNING)\\n\",\n \"\\n\",\n \"logger.debug(\\\"This is debug\\\")\\n\",\n \"logger.info(\\\"This is info\\\")\\n\",\n \"logger.warning(\\\"This is warning\\\")\\n\",\n \"logger.error(\\\"This is error\\\")\\n\",\n \"logger.critical(\\\"This is critical\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Logging expections\\n\",\n \"There's a neat `exception` function in `logging` module which will automatically log the stack trace in addition to user defined log entry. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"try:\\n\",\n \" path_calculation = 1 / 0\\n\",\n \"except ZeroDivisionError:\\n\",\n \" logging.exception(\\\"All went south in my calculation\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Formatting log entries\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import logging\\n\",\n \"\\n\",\n \"# This is only required for Jupyter notebook environment\\n\",\n \"from importlib import reload\\n\",\n \"\\n\",\n \"reload(logging)\\n\",\n \"\\n\",\n \"my_format = \\\"%(asctime)s | %(name)-12s | %(levelname)-10s | %(message)s\\\"\\n\",\n \"logging.basicConfig(format=my_format)\\n\",\n \"\\n\",\n \"logger = logging.getLogger(\\\"MyLogger\\\")\\n\",\n \"\\n\",\n \"logger.warning(\\\"Something bad is going to happen\\\")\\n\",\n \"logger.error(\\\"Uups, it already happened\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Logging to a file\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import logging\\n\",\n \"from pathlib import Path\\n\",\n \"\\n\",\n \"# This is only required for Jupyter notebook environment\\n\",\n \"from importlib import reload\\n\",\n \"\\n\",\n \"reload(logging)\\n\",\n \"\\n\",\n \"logger = logging.getLogger(\\\"MyFileLogger\\\")\\n\",\n \"\\n\",\n \"# Let's define a file_handler for our logger\\n\",\n \"log_path = Path.cwd() / \\\"my_log.txt\\\"\\n\",\n \"file_handler = logging.FileHandler(log_path)\\n\",\n \"\\n\",\n \"# And a nice format\\n\",\n \"formatter = logging.Formatter(\\n\",\n \" \\\"%(asctime)s | %(name)-12s | %(levelname)-10s | %(message)s\\\"\\n\",\n \")\\n\",\n \"file_handler.setFormatter(formatter)\\n\",\n \"\\n\",\n \"logger.addHandler(file_handler)\\n\",\n \"\\n\",\n \"# If you want to see it also in the console, add another handler for it\\n\",\n \"# logger.addHandler(logging.StreamHandler())\\n\",\n \"\\n\",\n \"logger.warning(\\\"Oops something is going to happen\\\")\\n\",\n \"logger.error(\\\"John Doe visits our place\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`random`](https://docs.python.org/3/library/random.html) for random number generation\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import random\\n\",\n \"\\n\",\n \"rand_int = random.randint(1, 100)\\n\",\n \"print(f\\\"random integer between 1-100: {rand_int}\\\")\\n\",\n \"\\n\",\n \"rand = random.random()\\n\",\n \"print(f\\\"random float between 0-1: {rand}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If you need pseudo random numbers, you can set the `seed` for random. This will reproduce the output (try running the cell multiple times):\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import random\\n\",\n \"\\n\",\n \"random.seed(5) # Setting the seed\\n\",\n \"\\n\",\n \"# Let's print 10 random numbers\\n\",\n \"for _ in range(10):\\n\",\n \" print(random.random())\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`re`](https://docs.python.org/3/library/re.html#module-re) for regular expressions\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Searching occurences\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import re\\n\",\n \"\\n\",\n \"secret_code = \\\"qwret 8sfg12f5 fd09f_df\\\"\\n\",\n \"# \\\"r\\\" at the beginning means raw format, use it with regular expression patterns\\n\",\n \"search_pattern = r\\\"(g12)\\\"\\n\",\n \"\\n\",\n \"match = re.search(search_pattern, secret_code)\\n\",\n \"print(f\\\"match: {match}\\\")\\n\",\n \"print(f\\\"match.group(): {match.group()}\\\")\\n\",\n \"\\n\",\n \"numbers_pattern = r\\\"[0-9]\\\"\\n\",\n \"numbers_match = re.findall(numbers_pattern, secret_code)\\n\",\n \"print(f\\\"numbers: {numbers_match}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Variable validation\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import re\\n\",\n \"\\n\",\n \"\\n\",\n \"def validate_only_lower_case_letters(to_validate):\\n\",\n \" pattern = r\\\"^[a-z]+$\\\"\\n\",\n \" return bool(re.match(pattern, to_validate))\\n\",\n \"\\n\",\n \"\\n\",\n \"print(validate_only_lower_case_letters(\\\"thisshouldbeok\\\"))\\n\",\n \"print(validate_only_lower_case_letters(\\\"thisshould notbeok\\\"))\\n\",\n \"print(validate_only_lower_case_letters(\\\"Thisshouldnotbeok\\\"))\\n\",\n \"print(validate_only_lower_case_letters(\\\"thisshouldnotbeok1\\\"))\\n\",\n \"print(validate_only_lower_case_letters(\\\"\\\"))\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/16_testing2.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Testing with [pytest](https://docs.pytest.org/en/latest/) - part 2\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Let's make sure pytest and ipytest packages are installed\\n\",\n \"# ipytest is required for running pytest inside Jupyter notebooks\\n\",\n \"import sys\\n\",\n \"\\n\",\n \"!{sys.executable} -m pip install pytest\\n\",\n \"!{sys.executable} -m pip install ipytest\\n\",\n \"\\n\",\n \"# These are needed for running pytest inside Jupyter notebooks\\n\",\n \"import ipytest\\n\",\n \"\\n\",\n \"ipytest.autoconfig()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`@pytest.fixture`](https://docs.pytest.org/en/latest/fixture.html#pytest-fixtures-explicit-modular-scalable)\\n\",\n \"Let's consider we have an implemention of `Person` class which we want to test.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Person:\\n\",\n \" def __init__(self, first_name, last_name, age):\\n\",\n \" self.first_name = first_name\\n\",\n \" self.last_name = last_name\\n\",\n \" self.age = age\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def full_name(self):\\n\",\n \" return f\\\"{self.first_name} {self.last_name}\\\"\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def as_dict(self):\\n\",\n \" return {\\\"name\\\": self.full_name, \\\"age\\\": self.age}\\n\",\n \"\\n\",\n \" def increase_age(self, years):\\n\",\n \" if years < 0:\\n\",\n \" raise ValueError(\\\"Can not make people younger :(\\\")\\n\",\n \" self.age += years\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"You can easily create resusable testing code by using pytest fixtures. If you introduce your fixtures inside [_conftest.py_](https://docs.pytest.org/en/latest/fixture.html#conftest-py-sharing-fixture-functions), the fixtures are available for all your test cases. In general, the location of _conftest.py_ is at the root of your _tests_ directory.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import pytest\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.fixture()\\n\",\n \"def default_person():\\n\",\n \" person = Person(first_name=\\\"John\\\", last_name=\\\"Doe\\\", age=82)\\n\",\n \" return person\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Then you can utilize `default_person` fixture in the actual test cases. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest\\n\",\n \"\\n\",\n \"\\n\",\n \"def test_full_name(default_person): # Note: we use fixture as an argument of the test case\\n\",\n \" result = default_person.full_name\\n\",\n \" assert result == 'John Doe'\\n\",\n \" \\n\",\n \" \\n\",\n \"def test_as_dict(default_person):\\n\",\n \" expected = {'name': 'John Doe', 'age': 82}\\n\",\n \" result = default_person.as_dict\\n\",\n \" assert result == expected\\n\",\n \" \\n\",\n \" \\n\",\n \"def test_increase_age(default_person):\\n\",\n \" default_person.increase_age(1)\\n\",\n \" assert default_person.age == 83\\n\",\n \" \\n\",\n \" default_person.increase_age(10)\\n\",\n \" assert default_person.age == 93\\n\",\n \" \\n\",\n \" \\n\",\n \"def test_increase_age_with_negative_number(default_person):\\n\",\n \" with pytest.raises(ValueError):\\n\",\n \" default_person.increase_age(-1)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"By using a fixture, we could use the same `default_person` for all our four test cases!\\n\",\n \"\\n\",\n \"In the `test_increase_age_with_negative_number` we used [`pytest.raises`](https://docs.pytest.org/en/latest/assert.html#assertions-about-expected-exceptions) to verify that an exception is raised. \"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`@pytest.mark.parametrize`](https://docs.pytest.org/en/latest/parametrize.html#pytest-mark-parametrize-parametrizing-test-functions)\\n\",\n \"Sometimes you want to test the same functionality with multiple different inputs. `pytest.mark.parametrize` is your solution for defining multiple different inputs with expected outputs. Let's consider the following implementation of `replace_names` function. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def replace_names(original_str, new_name):\\n\",\n \" \\\"\\\"\\\"Replaces names (uppercase words) of original_str by new_name\\\"\\\"\\\"\\n\",\n \" words = original_str.split()\\n\",\n \" manipulated_words = [new_name if w.istitle() else w for w in words]\\n\",\n \" return \\\" \\\".join(manipulated_words)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"We can test the `replace_names` function with multiple inputs by using `pytest.mark.parametrize`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.mark.parametrize(\\\"original,new_name,expected\\\", [\\n\",\n \" ('this is Lisa', 'John Doe', 'this is John Doe'),\\n\",\n \" ('how about Frank and Amy', 'John', 'how about John and John'),\\n\",\n \" ('no names here', 'John Doe', 'no names here'),\\n\",\n \" ])\\n\",\n \"def test_replace_names(original, new_name, expected):\\n\",\n \" result = replace_names(original, new_name)\\n\",\n \" assert result == expected\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/17_venv.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Virtual environment\\n\",\n \"When working with Python projects, best practice is to have a separate virtual environment for each of them. \\n\",\n \"\\n\",\n \"Each virtual environment has its own Python binary. When you install some Python package into your virtual environment, it'll be installed only into that specific environment. This means that you can have different versions of a single Python package in different virtual environments in the same machine. Virtual environments are also useful if you need to use different Python versions in your projects.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`venv`](https://docs.python.org/3/library/venv.html#module-venv)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### Creating new virtual environment\\n\",\n \"You can create all your virtual environments into a single directory (for example, `.virtualenvs` directory inside your home folder). This makes them easier to find.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"`python3 -m venv /path/to/new/environment`\\n\",\n \"\\n\",\n \"or\\n\",\n \"\\n\",\n \"`path/to/your/python -m venv /path/to/new/environment`\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### Activating the virtual environment\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Windows: `path_to_virtual_env\\\\Scripts\\\\activate.bat`
\\n\",\n \"Posix: `source path_to_virtual_env/bin/activate`\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### Installing packages\\n\",\n \"After activating the newly created virtual environment, you can install new packages by using `pip`. For example if you want to install `pytest`:\\n\",\n \"\\n\",\n \"`python -m pip install pytest`\\n\",\n \"\\n\",\n \"it'll be installed into path_to_virtual_env/lib//site-packages. Note that the path to site-packages maybe slightly different depending on the operating system you are using.\\n\",\n \"\\n\",\n \"You can list the installed packages and their versions by running:\\n\",\n \"\\n\",\n \"`python -m pip freeze`\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/beginner/notebooks/18_project_structure.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Project structure\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Python script\\n\",\n \"Python is a great language for building small helper tools for various different kinds of tasks. Such small tools can be often expressed as a single file Python script.\\n\",\n \"\\n\",\n \"Here is an example structure for a Python script (aka executable Python module).\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# the content of my_script.py\\n\",\n \"\\n\",\n \"# imports\\n\",\n \"import logging\\n\",\n \"\\n\",\n \"# constants\\n\",\n \"LOGGER = logging.getLogger()\\n\",\n \"\\n\",\n \"\\n\",\n \"def magical_function():\\n\",\n \" LOGGER.warning(\\\"We are about to do some magical stuff\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"def main():\\n\",\n \" # The actual logic of the script\\n\",\n \" magical_function()\\n\",\n \"\\n\",\n \"\\n\",\n \"if __name__ == \\\"__main__\\\":\\n\",\n \" main()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Python package\\n\",\n \"An example structure for a python project:\\n\",\n \"\\n\",\n \"```\\n\",\n \"my_project/\\n\",\n \" README.md\\n\",\n \" requirements.txt\\n\",\n \" setup.py\\n\",\n \" \\n\",\n \" src/\\n\",\n \" my_project/\\n\",\n \" __init__.py\\n\",\n \" my_module.py\\n\",\n \" other_module.py\\n\",\n \" \\n\",\n \" my_pkg1/\\n\",\n \" __init__.py\\n\",\n \" my_third_module.py\\n\",\n \" \\n\",\n \" tests/\\n\",\n \" conftest.py\\n\",\n \" test_module.py\\n\",\n \" test_other_module.py\\n\",\n \" \\n\",\n \" my_pkg1/\\n\",\n \" test_my_third_module.py\\n\",\n \"\\n\",\n \"```\\n\",\n \"\\n\",\n \"* [requirements.txt](https://pip.pypa.io/en/latest/user_guide/#requirements-files) lists the Python packages from which my_project depends on.\\n\",\n \" * these can be installed by running `pip install -r requirements`\\n\",\n \"* [setup.py](https://packaging.python.org/tutorials/distributing-packages/#setup-py) is a file in which you include relevant information about your project and the file is also used for packaging your project. Here's a minimal example of a setup.py:\\n\",\n \"\\n\",\n \"```python\\n\",\n \"'''Minimal setup.py file'''\\n\",\n \"\\n\",\n \"from setuptools import setup, find_packages\\n\",\n \"\\n\",\n \"setup(\\n\",\n \" name='my_project',\\n\",\n \" version='0.1',\\n\",\n \" packages=find_packages(where=\\\"src\\\"),\\n\",\n \" package_dir={\\\"\\\": \\\"src\\\"})\\n\",\n \"```\\n\",\n \"* Once you have the setup.py file in place, you can install your project in editable mode by running `pip install -e .` in the root directory of your project. In editable mode the installed version is updated when you make changes to the source code files.\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/data/empty.txt", "content": "" }, { "path": "notebooks/intermediate/data/misc_data1.txt", "content": "1\nJohn\nDoe\nJohn\n2\n99\nJohn\n\nwas\n\nhere\n6.72\nthis\n2\nis\n2\ntotally\nrandom\n2.0\njohn" }, { "path": "notebooks/intermediate/data/misc_data2.txt", "content": "1\nJohn\nDoe\nJohn\n2\n101\nJohn\nDoe\nwas\ndOe\nhere\n6.72\nthis\n2\nis\n2\n\n\n\n67\ntotally\nrandom\n2.0\njohn\ndoE" }, { "path": "notebooks/intermediate/exercises/01_std_lib2_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Let's mock things!\\n\",\n \"Below you can see `get_wiki_article` function which is a very simple implementation for fetching an article from wikipedia. Your task is to mock it's implementation such that it's going to always return `'Python is cool!'`. However, note that you should be able to check which argument is given to `urlopen` when `get_wiki_article` is called.\\n\",\n \"\\n\",\n \"**Note**: `get_content_of_url` uses [`urrlib`](https://docs.python.org/3/library/urllib.html#module-urllib), which is part of the Standard Library, for creating a HTTP request. Usually it's preferable to use [`requests`](http://docs.python-requests.org/en/master/) library (not part of the Standard Library) for such operations. Actually, `requests` uses `urllib` under the hood so it's good to know what's happening when you start using `requests` - or maybe you have already used it.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"from urllib.request import urlopen\\n\",\n \"\\n\",\n \"\\n\",\n \"def get_wiki_article(name):\\n\",\n \" url = f\\\"https://en.wikipedia.org/wiki/{name}\\\"\\n\",\n \" response = urlopen(url)\\n\",\n \" content = str(response.read())\\n\",\n \" return content\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's verify it works as expected.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"article = \\\"Python_(programming_language)\\\"\\n\",\n \"res = get_wiki_article(article)\\n\",\n \"assert \\\"Guido van Rossum\\\" not in res, \\\"Guido is still there!\\\"\\n\",\n \"assert res == \\\"Python is cool!\\\"\\n\",\n \"urlopen.assert_called_with(\\n\",\n \" \\\"https://en.wikipedia.org/wiki/Python_(programming_language)\\\"\\n\",\n \")\\n\",\n \"\\n\",\n \"print(\\\"All good!\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 2. The power of `collections` module\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## 2.1 Creating a namedtuple\\n\",\n \"Create a namedtuple `Car` which has fields `price`, `mileage`, and `brand`. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your implemenation here\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's test it.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"car1 = Car(25000, 2000, \\\"BMW\\\")\\n\",\n \"assert car1.price == 25000\\n\",\n \"assert car1.mileage == 2000\\n\",\n \"assert car1.brand == \\\"BMW\\\"\\n\",\n \"assert isinstance(car1, tuple)\\n\",\n \"\\n\",\n \"# Note that indexing works also!\\n\",\n \"# This means that if you change a tuple into a namedtuple,\\n\",\n \"# the change will be backwards compatible.\\n\",\n \"assert car1[2] == \\\"BMW\\\"\\n\",\n \"\\n\",\n \"print(\\\"All good!\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"The power of namedtuples is their simplicity. If `Car` would have been implemented as a class, the implementation would have been notably longer. However, if you would need to be able to e.g. change the `mileage` or `price` during the lifetime of a `Car` instance, consider using `class` because `tuples` are immutable.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## 2.2 dict of dicts\\n\",\n \"Implement a `name_mapping` function which takes a collection of names as argument. \\n\",\n \"\\n\",\n \"#### The specification for `name_mapping`\\n\",\n \"* you can assume that all the elements in the names collection are strings\\n\",\n \"* if the provided names collection is empty, returns an empty dict\\n\",\n \"* returns a dictionary of dictionaries\\n\",\n \" * outer dictionary should contain keys `vowel` and `consonant`\\n\",\n \" * `vowel` and `consonant` keys should have dictionaries of names (keys) and their occurences (values) as values\\n\",\n \" * names belong to either `vowel` or `consonant` based on their first letter\\n\",\n \" * vowels are defined by the `VOWELS` constant\\n\",\n \" * if there are only names starting with a vowel, `consonant` key should not be present in the return value (same applies vice versa)\\n\",\n \"* see the tests below for complete examples \\n\",\n \"\\n\",\n \"Tip: `defaultdict` and `Counter` may be helpful here :)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"VOWELS = (\\\"a\\\", \\\"e\\\", \\\"i\\\", \\\"o\\\", \\\"u\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def name_mapping(names):\\n\",\n \" # Your implementation here\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Let's verify that it works correctly!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"names = (\\\"Alice\\\", \\\"John\\\", \\\"Lisa\\\", \\\"John\\\", \\\"Eric\\\", \\\"Waldo\\\", \\\"annie\\\", \\\"Alice\\\", \\\"John\\\")\\n\",\n \"expected = {\\n\",\n \" \\\"consonant\\\": {\\\"John\\\": 3, \\\"Waldo\\\": 1, \\\"Lisa\\\": 1},\\n\",\n \" \\\"vowel\\\": {\\\"Alice\\\": 2, \\\"annie\\\": 1, \\\"Eric\\\": 1},\\n\",\n \"}\\n\",\n \"assert name_mapping(names) == expected\\n\",\n \"print(\\\"First ok!\\\")\\n\",\n \"\\n\",\n \"only_consonants = (\\\"John\\\", \\\"Doe\\\", \\\"Doe\\\")\\n\",\n \"expected2 = {\\\"consonant\\\": {\\\"John\\\": 1, \\\"Doe\\\": 2}}\\n\",\n \"assert name_mapping(only_consonants) == expected2\\n\",\n \"print(\\\"Second ok!\\\")\\n\",\n \"\\n\",\n \"assert name_mapping([]) == {}\\n\",\n \"\\n\",\n \"print(\\\"All ok!\\\")\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/exercises/05_idiomatic_python_exercise.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# 1. Let's make it more idiomatic\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Your task is to refactor the following report generation code to more idiomatic. The existing implementation was written by an unknown developer who did not know anything about the idioms of Python. Luckily the unkown developer documented the implementation decently and wrote some tests for it. \\n\",\n \"\\n\",\n \"### The specification of the report generation\\n\",\n \"\\n\",\n \"This file content:\\n\",\n \"```\\n\",\n \"something\\n\",\n \"1\\n\",\n \"7\\n\",\n \"somEThing\\n\",\n \"\\n\",\n \"2\\n\",\n \"wassup\\n\",\n \"woop\\n\",\n \"woop\\n\",\n \"something\\n\",\n \"WoOP\\n\",\n \"```\\n\",\n \"\\n\",\n \"Should yield this report:\\n\",\n \"```\\n\",\n \"missing values: 1\\n\",\n \"highest number: 7.0\\n\",\n \"most common words: something, woop\\n\",\n \"occurrences of most common: 3\\n\",\n \"#####\\n\",\n \"numbers: [1.0, 7.0, 2.0]\\n\",\n \"words: ['something', 'something', 'wassup', 'woop', 'woop', 'something', 'woop']\\n\",\n \"```\\n\",\n \"\\n\",\n \"Note:\\n\",\n \"* all numbers of the input file should be presented as floats in the report\\n\",\n \"* all words are presented as lowercased in the report\\n\",\n \"* while calculating the most common words, the count should be done as case insensitive (in other words, `'WoOp'` should be considered the same word as `'woop'`)\\n\",\n \"* if there are multiple different most common words, they should be presented in the format presented above\\n\",\n \"* there are more examples in the tests\\n\",\n \"\\n\",\n \"Run the cell of the existing implementation and then run the tests to verify that it works correctly. Then make sure that you understand how the legacy implementation works. After that, start refactoring, a function by function. Good luck!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"def get_report(path):\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" Creates a report of the file specified as argument.\\n\",\n \"\\n\",\n \" :param path: path to file from which the report should be created (string)\\n\",\n \" :return: the report (string)\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" data = _read_file(path)\\n\",\n \" missing_count = data[0]\\n\",\n \" numbers = data[1]\\n\",\n \" words = data[2]\\n\",\n \" report = _make_report(missing_count, numbers, words)\\n\",\n \" return report\\n\",\n \"\\n\",\n \"\\n\",\n \"def _read_file(path):\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" Reads and returns the data from the file specified as argument.\\n\",\n \"\\n\",\n \" :param path: path to the file to be read.\\n\",\n \" :return: a tuple containing\\n\",\n \" 1. the number of empty lines (int)\\n\",\n \" 2. numeric values (list of floats)\\n\",\n \" 3. non-numeric values (list of strings)\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" data_file = open(path)\\n\",\n \" lines = data_file.readlines()\\n\",\n \" line_count = len(lines)\\n\",\n \" idx = 0\\n\",\n \" empty_lines = 0\\n\",\n \" words = []\\n\",\n \" numbers = []\\n\",\n \" while idx < line_count:\\n\",\n \" line = lines[idx]\\n\",\n \" line = line.strip()\\n\",\n \" if line == \\\"\\\":\\n\",\n \" empty_lines = empty_lines + 1\\n\",\n \" else:\\n\",\n \" is_number = False\\n\",\n \" try:\\n\",\n \" number = float(line)\\n\",\n \" is_number = True\\n\",\n \" except Exception:\\n\",\n \" pass\\n\",\n \"\\n\",\n \" if is_number:\\n\",\n \" numbers.append(number)\\n\",\n \" else:\\n\",\n \" words.append(line)\\n\",\n \" idx = idx + 1\\n\",\n \" data_file.close()\\n\",\n \"\\n\",\n \" return empty_lines, numbers, words\\n\",\n \"\\n\",\n \"\\n\",\n \"def _make_report(missing_values, numbers, words):\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" Creates and a report based on data given as arguments.\\n\",\n \"\\n\",\n \" :param missing_values: number of empty lines (int)\\n\",\n \" :param numbers: numeric values (list of floats)\\n\",\n \" :param words: non numeric values (list of strings)\\n\",\n \" :return: the generated report (string)\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" max_value = _get_max_value(numbers)\\n\",\n \" lower_case_words = _words_to_lowercase(words)\\n\",\n \" most_common_info = _get_most_common_words(lower_case_words)\\n\",\n \" most_common_words = most_common_info[0]\\n\",\n \" most_common_count = most_common_info[1]\\n\",\n \"\\n\",\n \" most_common_str = \\\"\\\"\\n\",\n \" for idx in range(len(most_common_words)):\\n\",\n \" most_common_str += most_common_words[idx] + \\\", \\\"\\n\",\n \" # remove the last comma and space\\n\",\n \" most_common_str = most_common_str[0 : len(most_common_str) - 2]\\n\",\n \"\\n\",\n \" report = (\\n\",\n \" \\\"missing values: {}\\\\n\\\"\\n\",\n \" \\\"highest number: {}\\\\n\\\"\\n\",\n \" \\\"most common words: {}\\\\n\\\"\\n\",\n \" \\\"occurrences of most common: {}\\\\n\\\"\\n\",\n \" \\\"#####\\\\n\\\"\\n\",\n \" \\\"numbers: {}\\\\n\\\"\\n\",\n \" \\\"words: {}\\\"\\n\",\n \" ).format(\\n\",\n \" missing_values,\\n\",\n \" max_value,\\n\",\n \" most_common_str,\\n\",\n \" most_common_count,\\n\",\n \" numbers,\\n\",\n \" lower_case_words,\\n\",\n \" )\\n\",\n \"\\n\",\n \" return report\\n\",\n \"\\n\",\n \"\\n\",\n \"def _get_max_value(numbers):\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" Returns the greatest value of the list given as argument.\\n\",\n \"\\n\",\n \" :param numbers: numbers (list of numeric values)\\n\",\n \" :return: greatest value of numbers, None if numbers is an empty list\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" max_value = None\\n\",\n \" if len(numbers) > 0:\\n\",\n \" max_value = numbers[0]\\n\",\n \" for idx in range(len(numbers)):\\n\",\n \" if numbers[idx] > max_value:\\n\",\n \" max_value = numbers[idx]\\n\",\n \" return max_value\\n\",\n \"\\n\",\n \"\\n\",\n \"def _words_to_lowercase(words):\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" :param words: words to be converted (list of strings)\\n\",\n \" :return: lowercased words (list of strings)\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" lowercased = []\\n\",\n \" for idx in range(len(words)):\\n\",\n \" value = words[idx].lower()\\n\",\n \" lowercased.append(value)\\n\",\n \" return lowercased\\n\",\n \"\\n\",\n \"\\n\",\n \"def _get_most_common_words(words):\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" Finds the most common words in a list of words.\\n\",\n \" If there are multiple different words with the same amount of occurrences,\\n\",\n \" they are all included in the return value sorted alphabetically.\\n\",\n \" In addition to returning the most common words, the return value\\n\",\n \" includes also the count of occurrences of the most common words.\\n\",\n \"\\n\",\n \" :param words: list of words (list of strings)\\n\",\n \" :return: a tuple containing:\\n\",\n \" 1. most common words (list of strings)\\n\",\n \" 2. the count of occurrences of the most common words (int)\\n\",\n \" \\\"\\\"\\\"\\n\",\n \" word_counts = {}\\n\",\n \" idx = 0\\n\",\n \" while idx < len(words):\\n\",\n \" value = words[idx]\\n\",\n \" if value not in word_counts.keys():\\n\",\n \" word_counts[value] = 1\\n\",\n \" else:\\n\",\n \" word_counts[value] += 1\\n\",\n \" idx = idx + 1\\n\",\n \"\\n\",\n \" max_count = 0\\n\",\n \" for value in word_counts.values():\\n\",\n \" if value > max_count:\\n\",\n \" max_count = value\\n\",\n \"\\n\",\n \" most_common_words = []\\n\",\n \" for word in word_counts.keys():\\n\",\n \" count = word_counts[word]\\n\",\n \" if count == max_count:\\n\",\n \" most_common_words.append(word)\\n\",\n \"\\n\",\n \" most_common_words = sorted(most_common_words)\\n\",\n \"\\n\",\n \" return most_common_words, max_count\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Now it's time refactor the existing code to make it more idiomatic.\\n\",\n \"\\n\",\n \"It's desirable that you do the refactoring in small chunks. Consider using the following workflow:\\n\",\n \"1. Copy-paste a single function from the above ugly implementation to the cell below\\n\",\n \"2. Refactor the function\\n\",\n \"3. Run the tests to verify that you did not break anything\\n\",\n \"\\n\",\n \"This way you can consider each function as a separate sub task.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Your beautiful refactored, idiomatic, pythonic solution here\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"The tests are here. Run these often while refactoring!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {\n \"editable\": false\n },\n \"outputs\": [],\n \"source\": [\n \"from pathlib import Path\\n\",\n \"\\n\",\n \"CURRENT_DIR = Path.cwd()\\n\",\n \"DATA_DIR = CURRENT_DIR.parent / \\\"data\\\"\\n\",\n \"\\n\",\n \"DATA_FILE1 = DATA_DIR / \\\"misc_data1.txt\\\"\\n\",\n \"DATA_FILE2 = DATA_DIR / \\\"misc_data2.txt\\\"\\n\",\n \"DATA_FILE3 = DATA_DIR / \\\"empty.txt\\\"\\n\",\n \"\\n\",\n \"\\n\",\n \"expected1 = \\\"\\\"\\\"missing values: 2\\n\",\n \"highest number: 99.0\\n\",\n \"most common words: john\\n\",\n \"occurrences of most common: 4\\n\",\n \"#####\\n\",\n \"numbers: [1.0, 2.0, 99.0, 6.72, 2.0, 2.0, 2.0]\\n\",\n \"words: ['john', 'doe', 'john', 'john', 'was', 'here', 'this', 'is', 'totally', 'random', 'john']\\\"\\\"\\\"\\n\",\n \"\\n\",\n \"expected2 = \\\"\\\"\\\"missing values: 3\\n\",\n \"highest number: 101.0\\n\",\n \"most common words: doe, john\\n\",\n \"occurrences of most common: 4\\n\",\n \"#####\\n\",\n \"numbers: [1.0, 2.0, 101.0, 6.72, 2.0, 2.0, 67.0, 2.0]\\n\",\n \"words: ['john', 'doe', 'john', 'john', 'doe', 'was', 'doe', 'here', 'this', 'is', 'totally', 'random', 'john', 'doe']\\\"\\\"\\\"\\n\",\n \"\\n\",\n \"expected3 = \\\"\\\"\\\"missing values: 0\\n\",\n \"highest number: None\\n\",\n \"most common words: \\n\",\n \"occurrences of most common: 0\\n\",\n \"#####\\n\",\n \"numbers: []\\n\",\n \"words: []\\\"\\\"\\\"\\n\",\n \"\\n\",\n \"assert get_report(DATA_FILE1) == expected1\\n\",\n \"print(\\\"First one OK!\\\")\\n\",\n \"\\n\",\n \"assert get_report(DATA_FILE2) == expected2\\n\",\n \"print(\\\"Second one OK!\\\")\\n\",\n \"\\n\",\n \"assert get_report(DATA_FILE3) == expected3\\n\",\n \"print(\\\"All OK, woop woop!\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# If the tests are failing, you can debug here.\\n\",\n \"\\n\",\n \"report = get_report(DATA_FILE1)\\n\",\n \"print(report)\"\n ]\n }\n ],\n \"metadata\": {\n \"celltoolbar\": \"Edit Metadata\",\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/html/01_best_practices.html", "content": "\n\n\n\n\n01_best_practices\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

Best practices in development

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

One virtual environment per project

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • Isolation
    • \n
  • Different projects have different dependency versions
    • \n
  • You don't want to mess up the system Python
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling

poetry is currently the recommended tool for dependency management but "consider other tools such as pip when poetry does not meet your use case". If poetry doesn't fit your use case, I recommend using virtualenvwrapper for managing virtual environments and pip for package management. On the other hand, if you're working on only a couple of projects, built-in venv will do just fine.

\n

poetry

    \n
  • Basically combines pip, virtualenv, and packaging facilities under single CLI
    • \n
  • pyproject.toml which replaces the need for requirements.txt and requirements-dev.txt
    • \n
  • poetry.lock which pins dependencies, this means deterministic builds
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

virtualenvwrapper

    \n
  • If you are using Windows command prompt: virtualenvwrapper-win
    • \n
  • Like the name suggests, a wrapper around virtualenv
    • \n
  • Eases the workflow for creating, deleting, and (de)activating your virtual environments
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

pyenv

    \n
  • Easily change global / per project Python version
    • \n
  • Also a tool for installing different Python versions (also different runtimes available, e.g. PyPy)
    • \n
  • Useful if you'll need to work with different Python versions
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Test your code

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • No surprises (especially in production)
    • \n
  • Make sure that everything works as expected
    • \n
  • Make sure that old stuff works as expected after introducing new features (regression)
    • \n
  • Tests give you confidence while refactoring
    • \n
  • Good tests demonstrate the use cases of application, i.e. they also document the implementation
    • \n
  • ...
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling

pytest

There's unittest module in Python Standard Library but the go-to test runner nowadays is definitely pytest.

\n

Some reasons to use pytest:

\n\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

tox

tox makes it simple to test your code against different Python interpreter/runtime and dependency versions. This is important when you're writing software which should support different Python versions, which is usually the case with library-like packages. On the other hand, if you're developing, say, a web application which will be deployed to a known target platform, testing against multiple different versions is usually not necessary. However, tox makes it also possible to configure, for example, linting as part of tox run. Thus, tox may simplify the development workflow significantly by wrapping multiple different operations under a single command.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Write high quality code

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • Easy to read
    • \n
  • Better maintainability
    • \n
  • Better quality == less bugs
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
import this\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
The Zen of Python, by Tim Peters\n\nBeautiful is better than ugly.\nExplicit is better than implicit.\nSimple is better than complex.\nComplex is better than complicated.\nFlat is better than nested.\nSparse is better than dense.\nReadability counts.\nSpecial cases aren't special enough to break the rules.\nAlthough practicality beats purity.\nErrors should never pass silently.\nUnless explicitly silenced.\nIn the face of ambiguity, refuse the temptation to guess.\nThere should be one-- and preferably only one --obvious way to do it.\nAlthough that way may not be obvious at first unless you're Dutch.\nNow is better than never.\nAlthough never is often better than *right* now.\nIf the implementation is hard to explain, it's a bad idea.\nIf the implementation is easy to explain, it may be a good idea.\nNamespaces are one honking great idea -- let's do more of those!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Tooling - code formatters

PEP8 (see also "for humans version") describes the style guidelines for Python code, you should follow them. Luckily, there are awesome tools that handle this for you while you focus on writing code, not formatting it.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

black

    \n
  • This is the go-to formatter of the Python community
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling - linters

Automatic code formatting is great but in addition to that, you should use static analyzer (linter) to detect potential pitfalls in your code.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

ruff

    \n
  • Most comprehensive linter. As a bonus, it's extremely fast.
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling - pre-commit

pre-commit

Ideally, all project contributors should follow the best practices of the project, let it be e.g. respecting PEP8 or making sure there's no linting errors or security vulnerabilities in their change sets. However, as code formatters and linters are (mainly) local tools, this can not be guaranteed. pre-commit let's you configure (.pre-commit-config.yaml file) a set of hooks that will be run as pre actions to a commit/push. After a developer has called once pre-commit install, these hooks will be then automatically ran prior each commit/push.

\n
    \n
  • Run formatting before commit
    • \n
  • Fail the commit in case linting errors
    • \n
  • Even exercise the test suite before the code ends up to remote (might be time consuming in most scenarios though)
    • \n
  • Easy to configure your own hooks
    • \n
  • And use the existing ones
    • \n
  • There's also pre-push option
    • \n
  • Written in Python but supports also other languages, such as Ruby, Go, and Rust
    • \n
  • Less failed CI builds!
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Structure your code and projects

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • Package and module structure gives an overview about the project
    • \n
  • Modular design == better reusability
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

How

Some general guidelines:

\n
    \n
  • Don't put too much stuff into one module
    • \n
  • Split project into packages
    • \n
  • Be consistent with your naming conventions
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

A few words about structuring your projects. If you're developing, say, a relative big business application, it makes sense to separate some of the non-core business logic packages into a separate project and publish that as separate package. This way the "main" repository doesn't get bloated and it's more approachable for newcomers. Additionally, there's a change that you (or someone else) can easily reuse this "separated" package in the future, which is often the case e.g. for different kinds of utility functionalities.

\n

Let's take a practical example. If your team has two different applications which interact with the same third party, it's beneficial to implement a separate client library for communication with it. This way a change is needed only in one place (in the client library) if the third party decides to make a backwards incompatible change in their API.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling

cookiecutter

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Cookiecutter is a tool which let's you create projects from predefined templates.

\n
    \n
  • Rapid set-up of new projects, no need to copy paste from existing ones
    • \n
  • Consistent development practices across all projects (project structure as well as e.g. pre-commit, tox, and CI configuration)
    • \n
  • You can create one yourself or use some of the existing ones
    • \n
  • Written in Python but is applicable for non-Python projects as well, even non-programming related directory and file structures
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Use continuous integration and deployment

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

CI & CD belong to the best practices of software development without controversy, no matter what is the technology stack used for development. From Python point of view, CI is the place where we want to make sure that the other best practices described above are followed. For example, in bigger projects, it may not be even practical/possible to run the full test suite on developer's machine.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • Make sure the tests pass
    • \n
  • CI is the place where it's possible to run also some time consuming tests which the impatient developers prefer to skip on their local machines
    • \n
  • Make sure there's no linting errors
    • \n
  • Ideally, the place to test against all target versions and platforms
    • \n
  • Overall, CI is the last resort for automatically ensuring the quality
    • \n
  • Manual deployments are time consuming and error-prone, CD is automated and deterministic
    • \n
  • You want to automate as much as possible, human time is expensive
    • \n
  • Minimize the time required for code reviews - what could be detected with automatic tools, should be detected by using those tools. Human time is expensive.
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling

Tooling depends on which git repository manager option you've chosen and what kind of requirements you have. For example:

\n\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Utilize the capabitilies of your editor

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • Efficient and fluent development
    • \n
  • There's plenty of tools to make your daily programming easier, why would you not use them
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling

As there's a number of different editors and IDEs available, not to mention that everyone has their own preferences, I'll just focus on highlighting some of the features of my favorite IDE, PyCharm, which I highly recommend for Python development.

\n

PyCharm

    \n
  • Good integration with pytest, e.g. run single tests / test classes / test modules
    • \n
  • Git integration (in case you don't like command line)
    • \n
  • Easy to configure to use automatic formatting, e.g black
    • \n
  • Intuitive searching capabilities
    • \n
  • Refactoring features
    • \n
  • Debugger
    • \n
  • Jupyter Notebook integration
    • \n
  • Free community edition already contains all you need
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Use existing solutions

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • Python Standard Library is extensive - and stable!
    • \n
  • There are over 150k packages in PyPI
    • \n
  • Someone has most likely solved the problem you're trying to solve
    • \n
  • Spend 5 minutes doing a google research before starting to solve a new problem, e.g. stackoverflow is a magical place.
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Learn how to debug efficiently

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Why

    \n
  • You won't write completely stable code anyway - impossible looking conditions will occur.
    • \n
  • When something is not working as expected, there are plenty of tools out there to help you figure out what's going on.
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling - debuggers

pdb

    \n
  • Part of the Standard Library
    • \n
  • Sufficient for most use cases
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

ipdb

    \n
  • Feature rich pdb with similar API
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

pdb++

    \n
  • Drop-in replacement for pdb with additional features
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling - profilers

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

memray

    \n
  • Probably the only memory profiler you'll ever need
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

py-spy

    \n
  • Profile running Python program without the need for modifying the source code or restarting the target process
    • \n
  • Potential tool for identifying problems of e.g. a web application in production
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling - runtime error tracking

These are especially useful with web applications as you'll get reports - and notifications - of runtime exceptions with full tracebacks and variable values. This information is often enough for identifying the root cause of the problem, which is a huge benefit considering the time required for implementing and deploying the fix.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Sentry

    \n
  • Complete stack traces with relevant variable (locals()) values
    • \n
  • Browser and OS information of the client
    • \n
  • Support for other languages as well
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Tooling - misc

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Use logging instead of prints

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
    \n
  • logging is part of the Standard Library
    • \n
  • With logging you can redirect the output to a file
    • \n
  • Logs are usually the first place to look at after an end user reports an issue
    • \n
  • You can specify the runtime level - no need to remove the debug prints
    • \n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

General guidelines

    \n
  • If you're building applications, use the latest Python.
    • \n
  • If you're building libraries, make sure they support also older Python versions.
    • \n
  • Develop in branches. Even if you're the only person in the project, branching makes it possible to easily switch between different features / bug fixes.
    • \n
  • If you're not developing alone, practice code reviews. It's one of the best ways to learn for both parties.
    • \n
  • Document your master pieces
    • \n
\n\n
\n
\n
\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/intermediate/html/01_idiomatic_loops.html", "content": "\n\n\n\n\n01_idiomatic_loops\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

Idiomatic loops

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Looping in general

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
data = ["John", "Doe", "was", "here"]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this. While loops are actually really rarely needed.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
idx = 0\nwhile idx < len(data):\n    print(data[idx])\n    idx += 1\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John\nDoe\nwas\nhere\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do like this either.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
for idx in range(len(data)):\n    print(data[idx])\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John\nDoe\nwas\nhere\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
for item in data:\n    print(item)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John\nDoe\nwas\nhere\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

If you need the index as well, you can use enumerate.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
for idx, val in enumerate(data):\n    print(f"{idx}: {val}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0: John\n1: Doe\n2: was\n3: here\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Looping over a range of numbers

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Don't do this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
i = 0\nwhile i < 6:\n    print(i)\n    i += 1\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0\n1\n2\n3\n4\n5\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do this either.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
for val in [0, 1, 2, 3, 4, 5]:\n    print(val)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0\n1\n2\n3\n4\n5\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
for val in range(6):\n    print(val)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0\n1\n2\n3\n4\n5\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Reversed looping

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
data = ["first", "to", "last", "from"]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This is no good.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
i = len(data) - 1\nwhile i >= 0:\n    print(data[i])\n    i -= 1\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
from\nlast\nto\nfirst\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
for item in reversed(data):\n    print(item)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
from\nlast\nto\nfirst\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Looping over n collections simultaneously

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
collection1 = ["a", "b", "c"]\ncollection2 = (10, 20, 30, 40, 50)\ncollection3 = ["John", "Doe", True]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Oh boy, not like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
shortest = len(collection1)\nif len(collection2) < shortest:\n    shortest = len(collection2)\nif len(collection3) < shortest:\n    shortest = len(collection3)\n\ni = 0\nwhile i < shortest:\n    print(collection1[i], collection2[i], collection3[i])\n    i += 1\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
a 10 John\nb 20 Doe\nc 30 True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This is getting better but there's even a better way!

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
shortest = min(len(collection1), len(collection2), len(collection3))\nfor i in range(shortest):\n    print(collection1[i], collection2[i], collection3[i])\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
a 10 John\nb 20 Doe\nc 30 True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
for first, second, third in zip(collection1, collection2, collection3):\n    print(first, second, third)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
a 10 John\nb 20 Doe\nc 30 True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You can also create a dict out of two collections!

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [16]:
\n
\n
\n
my_dict = dict(zip(collection1, collection2))\nprint(my_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'a': 10, 'b': 20, 'c': 30}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

for - else - Checking for a match in a collection

Let's say we want to verify a certain condition is met by at least one element in a collection. Let's consider the following relatively naive example where we want to verify that at least one item is "python" (case insensitive) in data. If not, we'll raise a ValueError.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [17]:
\n
\n
\n
data = [1, 2, 3, "This", "is", "just", "a", "random", "Python", "list"]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [18]:
\n
\n
\n
found = False\nfor val in data:\n    if str(val).lower() == "python":\n        found = True\n        break\nif not found:\n    raise ValueError("Nope, couldn't find.")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [19]:
\n
\n
\n
for val in data:\n    if str(val).lower() == "python":\n        break\nelse:\n    raise ValueError("Nope, couldn't find.")\n
\n\n
\n
\n
\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/intermediate/html/01_pytest_fixtures.html", "content": "\n\n\n\n\n01_pytest_fixtures\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

Efficient use of pytest fixtures

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Required boilerplate for using pytest inside notebooks.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
# Let's make sure pytest and ipytest packages are installed\n# ipytest is required for running pytest inside Jupyter notebooks\nimport sys\n\n!{sys.executable} -m pip install pytest\n!{sys.executable} -m pip install ipytest\n\n# These are needed for running pytest inside Jupyter notebooks\nimport ipytest\n\nipytest.autoconfig()\n\nimport pytest\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Requirement already satisfied: pytest in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (7.3.1)\r\nRequirement already satisfied: tomli>=1.0.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (2.0.1)\r\nRequirement already satisfied: exceptiongroup>=1.0.0rc8 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (1.1.1)\r\nRequirement already satisfied: iniconfig in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (2.0.0)\r\nRequirement already satisfied: pluggy<2.0,>=0.12 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (1.0.0)\r\nRequirement already satisfied: packaging in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest) (23.1)\r\n\r\n[notice] A new release of pip available: 22.3.1 -> 23.1.1\r\n[notice] To update, run: pip install --upgrade pip\r\nRequirement already satisfied: ipytest in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (0.13.1)\r\nRequirement already satisfied: ipython in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (8.12.0)\r\nRequirement already satisfied: packaging in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (23.1)\r\nRequirement already satisfied: pytest>=5.4 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipytest) (7.3.1)\r\nRequirement already satisfied: tomli>=1.0.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (2.0.1)\r\nRequirement already satisfied: iniconfig in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (2.0.0)\r\nRequirement already satisfied: exceptiongroup>=1.0.0rc8 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (1.1.1)\r\nRequirement already satisfied: pluggy<2.0,>=0.12 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pytest>=5.4->ipytest) (1.0.0)\r\nRequirement already satisfied: jedi>=0.16 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.18.2)\r\nRequirement already satisfied: appnope in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.1.3)\r\nRequirement already satisfied: pickleshare in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.7.5)\r\nRequirement already satisfied: stack-data in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.6.2)\r\nRequirement already satisfied: prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (3.0.38)\r\nRequirement already satisfied: backcall in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.2.0)\r\nRequirement already satisfied: pygments>=2.4.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (2.15.0)\r\nRequirement already satisfied: decorator in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (5.1.1)\r\nRequirement already satisfied: traitlets>=5 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (5.9.0)\r\nRequirement already satisfied: pexpect>4.3 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (4.8.0)\r\nRequirement already satisfied: matplotlib-inline in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from ipython->ipytest) (0.1.6)\r\nRequirement already satisfied: parso<0.9.0,>=0.8.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from jedi>=0.16->ipython->ipytest) (0.8.3)\r\nRequirement already satisfied: ptyprocess>=0.5 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from pexpect>4.3->ipython->ipytest) (0.7.0)\r\nRequirement already satisfied: wcwidth in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from prompt-toolkit!=3.0.37,<3.1.0,>=3.0.30->ipython->ipytest) (0.2.6)\r\nRequirement already satisfied: executing>=1.2.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (1.2.0)\r\nRequirement already satisfied: asttokens>=2.1.0 in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (2.2.1)\r\nRequirement already satisfied: pure-eval in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from stack-data->ipython->ipytest) (0.2.2)\r\nRequirement already satisfied: six in /Users/jerrypussinen/.virtualenvs/learn-python/lib/python3.10/site-packages (from asttokens>=2.1.0->stack-data->ipython->ipytest) (1.16.0)\r\n\r\n[notice] A new release of pip available: 22.3.1 -> 23.1.1\r\n[notice] To update, run: pip install --upgrade pip\r\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Parametrizing fixtures

Similarly as you can parametrize test functions with pytest.mark.parametrize, you can parametrize fixtures:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
PATHS = ["/foo/bar.txt", "/bar/baz.txt"]\n\n\n@pytest.fixture(params=PATHS)\ndef executable(request):\n    return request.param\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
%%ipytest -s\n\ndef test_something_with_executable(executable):\n    print(executable)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
/foo/bar.txt\n./bar/baz.txt\n.\n2 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

pytest.mark.usefixtures

pytest.mark.usefixtures is useful especially when you want to use some fixture in a set of tests but you don't need the return value of the fixture.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
%%ipytest -s\n\n\n@pytest.fixture\ndef my_fixture():\n    print("\\nmy_fixture is used")\n  \n\n@pytest.fixture\ndef other_fixture():\n    return "FOO"\n\n\n@pytest.mark.usefixtures('my_fixture')\nclass TestMyStuff:\n    def test_somestuff(self):\n        pass\n    \n    def test_some_other_stuff(self, other_fixture):\n        print(f'here we use also other_fixture which returns: {other_fixture}')\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
\nmy_fixture is used\n.\nmy_fixture is used\nhere we use also other_fixture which returns: FOO\n.\n2 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

pytest built-in fixtures

Here are a couple of examples of the useful built-in fixtures, you can view all available fixtures by running pytest --fixtures.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

monkeypatch

Built-in monkeypatch fixture lets you e.g. set environment variables and set/delete attributes of objects. The use cases are similar as with patching/mocking with unittest.mock.patch/unittest.mock.MagicMock which are part of the Python Standard Library.

\n

Monkeypatching environment variables:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
import os\n\n\ndef get_env_var_or_none(var_name):\n    return os.environ.get(var_name, None)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
%%ipytest -s\n\ndef test_get_env_var_or_none_with_valid_env_var(monkeypatch):\n    monkeypatch.setenv('MY_ENV_VAR', 'secret')\n    res = get_env_var_or_none('MY_ENV_VAR')\n    assert res == 'secret'\n    \ndef test_get_env_var_or_none_with_missing_env_var():\n    res = get_env_var_or_none('NOT_EXISTING')\n    assert res is None\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
..\n2 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Monkeypatching attributes:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
class SomeClass:\n    some_value = "some value"\n\n    @staticmethod\n    def tell_the_truth():\n        print("This is the original truth")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
def fake_truth():\n    print("This is modified truth")\n\n\n@pytest.fixture\ndef fake_some_class(monkeypatch):\n    monkeypatch.setattr("__main__.SomeClass.some_value", "fake value")\n    monkeypatch.setattr("__main__.SomeClass.tell_the_truth", fake_truth)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
%%ipytest -s\n\ndef test_some_class(fake_some_class):\n    print(SomeClass.some_value)\n    SomeClass.tell_the_truth()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
fake value\nThis is modified truth\n.\n1 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

tmpdir

tmpdir fixture provides functionality for creating temporary files and directories.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
def word_count_of_txt_file(file_path):\n    with open(file_path) as f:\n        content = f.read()\n        return len(content.split())\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
%%ipytest -s\n\ndef test_word_count(tmpdir):\n    test_file = tmpdir.join('test.txt')\n    test_file.write('This is example content of seven words')\n    res = word_count_of_txt_file(str(test_file)) # str returns the path\n    assert res == 7\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
.\n1 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Fixture scope

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
@pytest.fixture(scope="function")\ndef func_fixture():\n    print("\\nfunc")\n\n\n@pytest.fixture(scope="module")\ndef module_fixture():\n    print("\\nmodule")\n\n\n@pytest.fixture(scope="session")\ndef session_fixture():\n    print("\\nsession")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
%%ipytest -s\n\ndef test_something(func_fixture, module_fixture, session_fixture):\n    pass\n\ndef test_something_else(func_fixture, module_fixture, session_fixture):\n    pass\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
\nsession\n\nmodule\n\nfunc\n.\nfunc\n.\n2 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Setup-teardown behaviour

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
@pytest.fixture\ndef some_fixture():\n    print("some_fixture is run now")\n    yield "some magical value"\n    print("\\nthis will be run after test execution, you can do e.g. some clean up here")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
%%ipytest -s\n\ndef test_something(some_fixture):\n    print('running test_something')\n    assert some_fixture == 'some magical value'\n    print('test ends here')\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
some_fixture is run now\nrunning test_something\ntest ends here\n.\nthis will be run after test execution, you can do e.g. some clean up here\n\n1 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Using fixtures automatically

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [16]:
\n
\n
\n
@pytest.fixture(autouse=True)\ndef my_fixture():\n    print("\\nusing my_fixture")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
In [17]:
\n
\n
\n
%%ipytest -s\n\ndef test_1():\n    pass\n    \ndef test_2():\n    pass\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
\nusing my_fixture\n.\nusing my_fixture\n.\n2 passed in 0.01s\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/intermediate/html/01_std_lib2.html", "content": "\n\n\n\n\n01_std_lib2\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

Goodies of the Python Standard Library

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

json for encoding and decoding JSON

Because the web is filled with JSON nowadays and the good days of xml are gone.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
data = {"b": True, "a": 1, "nested": {"foo": "bar"}, "c": None, "some_list": [1, 2, 3]}\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Encoding

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
import json\n\njson_data = json.dumps(data)\nprint(f"type: {type(json_data)} data: {json_data}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
type: <class 'str'> data: {"b": true, "a": 1, "nested": {"foo": "bar"}, "c": null, "some_list": [1, 2, 3]}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Decoding

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
decoded = json.loads(json_data)\nprint(f"type: {type(decoded)} data: {decoded}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
type: <class 'dict'> data: {'b': True, 'a': 1, 'nested': {'foo': 'bar'}, 'c': None, 'some_list': [1, 2, 3]}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

unittest.mock

Although pytest is the preferred testing framework, unittest.mock module offers some goodies that are helpful also in pytest test cases. Mocking and patching are generally useful for "faking" some parts of the logic/state of the software under test. Common use cases are, for example, patching parts of code that interact with 3rd parties (e.g. some web services).

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

MagicMock

In general, Mocks are simulated objects that replace the functionality/state of a real world object in a controlled way. Thus, they are especially useful in tests for mimicing some behavior of a specific part of the implementation under test.

\n

There is also a Mock class in the Python Standard Library but you usually want to use MagicMock which is a subclass of Mock. MagicMock provides default implementation for the most of the magic methods (e.g. __setitem__() and __getitem__())

\n

A potential use case could be something like this:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
import random\n\n\nclass Client:\n    def __init__(self, url, username, password):\n        self.url = url\n        self.creds = (username, password)\n\n    def fetch_some_data(self):\n        print(\n            "Here we could for example fetch data from 3rd party API and return the data."\n        )\n        print("Now we will just return some random number between 1-100.")\n        return random.randint(1, 100)\n\n\nclass MyApplication:\n    def __init__(self):\n        self.client = Client(\n            url="https://somewhere/api", username="John Doe", password="secret123?"\n        )\n\n    def do_something_fancy(self):\n        data = self.client.fetch_some_data()\n        return data ** (1 / 2)  # let's return a square root just for example\n\n\n####################\n# In the test module:\n\nfrom unittest.mock import MagicMock\n\n# Inside a test case:\napp = MyApplication()\napp.client = MagicMock()  # Mock the client\napp.client.fetch_some_data.return_value = 4  # Set controlled behaviour\nresult = app.do_something_fancy()\nassert result == 2\nprint("All good, woop woop!")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
All good, woop woop!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

patch

The use cases of patch are pretty similar to MacigMock. The biggest difference is that patch is used as a context manager or a decorator. Object to be patched is given as an argument for patch. In addition, you can provide additional object as a second argument (new) which will replace the original one. In case the new is omitted, MagicMock will be used by default.

\n

Let's see how the example above would look like with patch.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
# In the test module:\n\nfrom unittest.mock import patch\n\n# Inside a test case:\napp = MyApplication()\nwith patch("__main__.app.client") as patched_client:  # Patch the client\n    patched_client.fetch_some_data.return_value = 4  # Set controlled behaviour\n    result = app.do_something_fancy()\n    assert result == 2\n    print("All good, woop woop!")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
All good, woop woop!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

The same but with a function decorator instead of a context manager. Note that here we are patching the whole Client class, not just the client instance variable of app.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
from unittest.mock import patch\n\n\n@patch("__main__.Client")  # Patch the Client\ndef test_do_something_fancy(client_cls):\n    client_cls().fetch_some_data.return_value = 4  # Set controlled behaviour\n    app = MyApplication()\n    result = app.do_something_fancy()\n    assert result == 2\n    print("All good, woop woop!")\n\n\ntest_do_something_fancy()  # This is just for the sake of example\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
All good, woop woop!\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

collections

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

namedtuple

A great helper for creating more readable and self documenting code.

\n

namedtuple is a function that returns a tuple whose fields have names and also the tuple itself has a name (just like classes and their instance variables). Potential use cases include storing data which should be immutable. If you can use Python 3.7 or newer, you may want to take a look at dataclasses as well.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
from collections import namedtuple\n\nPerson = namedtuple("Person", ["name", "age", "is_gangster"])\n\n# instance creation is similar to classes\njohn = Person("John Doe", 83, True)\nlisa = Person("Lis Doe", age=77, is_gangster=False)\n\nprint(john, lisa)\nprint(f"Is John a gangster: {john.is_gangster}")\n\n# tuples are immutable, thus you can't do this\n# john.is_gangster = False\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Person(name='John Doe', age=83, is_gangster=True) Person(name='Lis Doe', age=77, is_gangster=False)\nIs John a gangster: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Counter

For counting the occurences of elements in a collection.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
from collections import Counter\n\ndata = [1, 2, 3, 1, 2, 4, 5, 6, 2]\n\ncounter = Counter(data)\nprint(f"type: {type(counter)}, counter: {counter}")\n\nprint(f"count of twos: {counter[2]}")\nprint(f"count of tens: {counter[10]}")  # zero for non existing\n\nprint(f"counter is a dict: {isinstance(counter, dict)}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
type: <class 'collections.Counter'>, counter: Counter({2: 3, 1: 2, 3: 1, 4: 1, 5: 1, 6: 1})\ncount of twos: 3\ncount of tens: 0\ncounter is a dict: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

defaultdict

For cleaner code for populating dictionaries.

\n

Let's first see how you could use a normal dict.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
data = (1, 2, 3, 4, 3, 2, 5, 6, 7)\n\nmy_dict = {}\nfor val in data:\n    if val % 2:\n        if not "odd" in my_dict:\n            my_dict["odd"] = []\n        my_dict["odd"].append(val)\n    else:\n        if not "even" in my_dict:\n            my_dict["even"] = []\n        my_dict["even"].append(val)\n\nprint(my_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'odd': [1, 3, 3, 5, 7], 'even': [2, 4, 2, 6]}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

With defaultdict:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
from collections import defaultdict\n\nmy_dict = defaultdict(list)\nfor val in data:\n    if val % 2:\n        my_dict["odd"].append(val)\n    else:\n        my_dict["even"].append(val)\nprint(my_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
defaultdict(<class 'list'>, {'odd': [1, 3, 3, 5, 7], 'even': [2, 4, 2, 6]})\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

In the above example, defaultdict makes sure that a fresh list is automatically initialized as a value when a new key is added.

\n

Here's another example with int as a default.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
my_dict = defaultdict(int)\nfor val in data:\n    if val % 2:\n        my_dict["odd_count"] += 1\n    else:\n        my_dict["even_count"] += 1\nprint(my_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
defaultdict(<class 'int'>, {'odd_count': 5, 'even_count': 4})\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/intermediate/html/02_idiomatic_dicts.html", "content": "\n\n\n\n\n02_idiomatic_dicts\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

Idiomatic dictionaries

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

get - default value of a non existing key while accessing

Especially handy if you're unsure about the presence of a key.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
my_dict = {"a": 1, "b": 2, "c": 3}\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
if "g" in my_dict:\n    value = my_dict["g"]\nelse:\n    value = "some default value"\nprint(value)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
some default value\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Or like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
try:\n    value = my_dict["g"]\nexcept KeyError:\n    value = "some default value"\nprint(value)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
some default value\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
value = my_dict.get("g", "some default value")\nprint(value)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
some default value\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Note that if you don't provide the default value for get, the return value will be None if the key is not present in the dictionary

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
value = my_dict.get("g")\nprint(value is None)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

setdefault - same as get but also sets the value if not present

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
my_dict = {"a": 1, "b": 2, "c": 3}\n\nkey = "g"\nif key in my_dict:\n    value = my_dict[key]\nelse:\n    value = "some default value"\n    my_dict[key] = value\n\nprint(value)\nprint(my_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
some default value\n{'a': 1, 'b': 2, 'c': 3, 'g': 'some default value'}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Let's do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
my_dict = {"a": 1, "b": 2, "c": 3}\n\nkey = "g"\nvalue = my_dict.setdefault(key, "some default value")\n\nprint(value)\nprint(my_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
some default value\n{'a': 1, 'b': 2, 'c': 3, 'g': 'some default value'}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Comprehensions

Let's say we have a collection of numbers and we want to store those as a dictionary where the number is key and it's square is the value.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
numbers = (1, 5, 10)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
squares = {}\nfor num in numbers:\n    squares[num] = num**2\nprint(squares)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{1: 1, 5: 25, 10: 100}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
squares = {num: num**2 for num in numbers}\nprint(squares)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{1: 1, 5: 25, 10: 100}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Another example

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
keys = ("a", "b", "c")\nvalues = [True, 100, "John Doe"]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
my_dict = {}\nfor idx, key in enumerate(keys):\n    my_dict[key] = values[idx]\nprint(my_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'a': True, 'b': 100, 'c': 'John Doe'}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
my_dict = {k: v for k, v in zip(keys, values)}\nprint(my_dict)\n\n# Or even like this:\nmy_dict2 = dict(zip(keys, values))\n\nassert my_dict2 == my_dict\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
{'a': True, 'b': 100, 'c': 'John Doe'}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Looping

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
my_dict = {"age": 83, "is gangster": True, "name": "John Doe"}\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
for key in my_dict:\n    val = my_dict[key]\n    print(f"key: {key:15s} value: {val}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
key: age             value: 83\nkey: is gangster     value: True\nkey: name            value: John Doe\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [16]:
\n
\n
\n
for key, val in my_dict.items():\n    print(f"key: {key:15s} value: {val}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
key: age             value: 83\nkey: is gangster     value: True\nkey: name            value: John Doe\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/intermediate/html/03_idiomatic_misc1.html", "content": "\n\n\n\n\n03_idiomatic_misc1\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

Idiomatic Python - miscellaneous part 1

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Comprehensions

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
original_data = (1, 2, 3, 4)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
# list\nsquare_roots_list = []\nfor val in original_data:\n    square_root = val ** (1 / 2)\n    square_roots_list.append(square_root)\nprint(square_roots_list)\n\n# set\nsquare_roots_set = set()\nfor val in original_data:\n    square_root = val ** (1 / 2)\n    square_roots_set.add(square_root)\nprint(square_roots_set)\n\n# dict\nsquare_roots_dict = {}\nfor val in original_data:\n    square_root = val ** (1 / 2)\n    square_roots_dict[val] = square_root\nprint(square_roots_dict)\n\n# dict with a condition\ninteger_square_roots_dict = {}\nfor val in original_data:\n    square_root = val ** (1 / 2)\n    if square_root.is_integer():\n        integer_square_roots_dict[val] = square_root\nprint(integer_square_roots_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
[1.0, 1.4142135623730951, 1.7320508075688772, 2.0]\n{1.0, 2.0, 1.7320508075688772, 1.4142135623730951}\n{1: 1.0, 2: 1.4142135623730951, 3: 1.7320508075688772, 4: 2.0}\n{1: 1.0, 4: 2.0}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Note: in case you're using 2.X version of Python for some reason, the result of 1/2 is 0 instead of 0.5.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Use comprehensions!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
square_roots_list = [val ** (1 / 2) for val in original_data]\nprint(square_roots_list)\n\nsquare_roots_set = {val ** (1 / 2) for val in original_data}\nprint(square_roots_set)\n\nsquare_roots_dict = {val: val ** (1 / 2) for val in original_data}\nprint(square_roots_dict)\n\ninteger_square_roots_dict = {\n    val: val ** (1 / 2) for val in original_data if (val ** (1 / 2)).is_integer()\n}\nprint(integer_square_roots_dict)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
[1.0, 1.4142135623730951, 1.7320508075688772, 2.0]\n{1.0, 2.0, 1.7320508075688772, 1.4142135623730951}\n{1: 1.0, 2: 1.4142135623730951, 3: 1.7320508075688772, 4: 2.0}\n{1: 1.0, 4: 2.0}\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Using in for checking presence of an element in a collection

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
name = "John Doe"\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
if name == "John" or name == "Doe" or name == "John Doe":\n    print("This seems to be our guy")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
This seems to be our guy\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
if name in ("John", "Doe", "John Doe"):\n    print("This seems to be our guy")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
This seems to be our guy\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Chained comparisons

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
a, b, c, d = 1, 2, 3, 4\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
if b > a and c > b and d > c:\n    print("from lowest to highest: a, b, c, d")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
from lowest to highest: a, b, c, d\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
if a < b < c < d:\n    print("from lowest to highest: a, b, c, d")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
from lowest to highest: a, b, c, d\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Falsy/truthy values

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
# These are falsy\nmy_list = []\nmy_dict = {}\nmy_set = set()\nmy_tuple = tuple()\nzero = 0\nfalse = False\nnone = None\nmy_str = ""\n\n# Basically the rest are truthy\n# for example:\nmy_second_list = ["foo"]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
if len(my_list) == 0:\n    print("Empty list is so empty")\n\nif not len(my_dict):\n    print("Empty dict is also very empty")\n\nif not len(my_set) and not len(my_tuple):\n    print("Same goes for sets and tuples")\n\nif not bool(zero) and not bool(false) and not bool(none) and len(my_str) == 0:\n    print("These are also falsy")\n\nif len(my_second_list) > 0:\n    print("This should be true")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Empty list is so empty\nEmpty dict is also very empty\nSame goes for sets and tuples\nThese are also falsy\nThis should be true\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This is much better!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
if not my_list:\n    print("Empty list is so empty")\n\nif not my_dict:\n    print("Empty dict is also very empty")\n\nif not my_set and not my_tuple:\n    print("Same goes for sets and tuples")\n\nif not zero and not false and not none and not my_str:\n    print("These are also falsy")\n\nif my_second_list:\n    print("This should be true")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Empty list is so empty\nEmpty dict is also very empty\nSame goes for sets and tuples\nThese are also falsy\nThis should be true\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

any & all

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
example_collection = ["a", True, "Python is cool", 123, 0]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
any_value_truthy = True\nfor val in example_collection:\n    if val:\n        any_value_truthy = True\n        break\n\nall_values_truthy = True\nfor val in example_collection:\n    if not val:\n        all_values_truthy = False\n        break\n\nprint(f"any truthy: {any_value_truthy}, all truthy: {all_values_truthy}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
any truthy: True, all truthy: False\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
any_value_truthy = any(example_collection)\nall_values_truthy = all(example_collection)\nprint(f"any truthy: {any_value_truthy}, all truthy: {all_values_truthy}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
any truthy: True, all truthy: False\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Pythonic substitute for ternary operator

Many other programming languages have a ternary operator: ?. A common use case for the ternary operator is to assign a certain value to a variable based on some condition. In other words, it could be used like this:

\n
variable = some_condition ? some_value : some_other_value\n
\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Instead of doing this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [16]:
\n
\n
\n
some_condition = True  # just a dummy condition\n\nif some_condition:\n    variable = "John"\nelse:\n    variable = "Doe"\nprint(variable)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

You can do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [17]:
\n
\n
\n
variable = "John" if some_condition else "Doe"\nprint(variable)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Function keywords arguments

For better readability and maintainability.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [18]:
\n
\n
\n
def show_person_details(name, is_gangster, is_hacker, age):\n    print(f"name: {name}, gangster: {is_gangster}, hacker: {is_hacker}, age: {age}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This is not good. It's hard to tell what True, False and 83 refer here if you are not familiar with the signature of the show_person_details function.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [19]:
\n
\n
\n
show_person_details("John Doe", True, False, 83)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
name: John Doe, gangster: True, hacker: False, age: 83\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This is much better!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [20]:
\n
\n
\n
show_person_details("John Doe", is_gangster=True, is_hacker=False, age=83)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
name: John Doe, gangster: True, hacker: False, age: 83\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Extra: keyword only arguments after *

This might be useful for example if the signature of the function is likely to change in the future. For example, if there's even a slight chance that one of the arguments may be dropped during the future development, consider using *.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [21]:
\n
\n
\n
def func_with_loads_of_args(arg1, *, arg2=None, arg3=None, arg4=None, arg5="boom"):\n    pass\n\n\n# This won't work because only keyword arguments allowed after *\n# func_with_loads_of_args('John Doe', 1, 2)\n\n# This is ok\nfunc_with_loads_of_args("John Doe", arg4="foo", arg5="bar", arg2="foo bar")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Multiple assigment

Let's say we want to swap the values of two variables.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [22]:
\n
\n
\n
# original values\na = 1\nb = 2\n\n# swap\ntmp = a\na = b\nb = tmp\nprint(a, b)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
2 1\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [23]:
\n
\n
\n
# original values\na = 1\nb = 2\n\n# swap\na, b = b, a\nprint(a, b)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
2 1\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

(Un)packing

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [24]:
\n
\n
\n
my_list = [1, 2, 3, 4, 5, 6]\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do something like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [25]:
\n
\n
\n
first = my_list[0]\nlast = my_list[-1]\nmiddle = my_list[1:-1]\nprint(first, middle, last)\n\npacked = [first] + middle + [last]\nassert packed == my_list\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
1 [2, 3, 4, 5] 6\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This is the Pythonic way!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [26]:
\n
\n
\n
# unpacking\nfirst, *middle, last = my_list\nprint(first, middle, last)\n\n# packing\npacked = [first, *middle, last]\nassert packed == my_list\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
1 [2, 3, 4, 5] 6\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/intermediate/html/04_idiomatic_misc2.html", "content": "\n\n\n\n\n04_idiomatic_misc2\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

Idiomatic Python - miscellaneous part 2

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

String concatenation

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [1]:
\n
\n
\n
names = ("John", "Lisa", "Terminator", "Python")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Don't do this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [2]:
\n
\n
\n
semicolon_separated = names[0]\nfor name in names[1:]:\n    semicolon_separated += ";" + name\nprint(semicolon_separated)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John;Lisa;Terminator;Python\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Use join instead!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [3]:
\n
\n
\n
semicolon_separated = ";".join(names)\nprint(semicolon_separated)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John;Lisa;Terminator;Python\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

or in assignments

The return value of a or b:

\n
    \n
  • a if a is truthy
    • \n
  • b otherwise
    • \n
\n

You can take advantage of this e.g. while writing variable assignments.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [4]:
\n
\n
\n
a = 0\nb = None\nc = "John Doe"\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Instead of doing something like this:

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [5]:
\n
\n
\n
my_variable = "default value"\nif a:\n    my_variable = a\nelif b:\n    my_variable = b\nelif c:\n    my_variable = c\nprint(my_variable)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John Doe\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Prefer doing this:

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [6]:
\n
\n
\n
my_variable = a or b or c or "default value"\nprint(my_variable)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John Doe\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

try - except - else

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Don't use the following technique for checking if there was exceptions during execution of some block of code.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [7]:
\n
\n
\n
exception_occured = False\ntry:\n    # here would be the logic of your master piece\n\n    bad_calculation = 1 / 0\n\nexcept ValueError as e:\n    print(f"Oh boi, some value error: {e}")\n    exception_occured = True\nexcept Exception as e:\n    print(f"Oh boi, something bad happened: {e}")\n    exception_occured = True\n\nif not exception_occured:\n    print("All went well!")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Oh boi, something bad happened: division by zero\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Use this instead!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [8]:
\n
\n
\n
try:\n    # here would be the logic of your master piece\n\n    bad_calculation = 1 / 0\n\nexcept ValueError as e:\n    print(f"Oh boi, some keyerror: {e}")\nexcept Exception as e:\n    print(f"Oh boi, something bad happened: {e}")\nelse:\n    print("All went well!")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Oh boi, something bad happened: division by zero\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

try - finally

For scenarios where you want to do something always, even when there are exceptions.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Don't do it like this

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [9]:
\n
\n
\n
def magical_calculation():\n    try:\n        # here would be the logic of your master piece\n        result = 1 / 0\n    except ZeroDivisionError:\n        print("This could be something important that should be done every time")\n        return 0\n    except Exception:\n        print("This could be something important that should be done every time")\n        return None\n\n    print("This could be something important that should be done every time")\n    return result\n\n\nprint(f"return value: {magical_calculation()}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
This could be something important that should be done every time\nreturn value: 0\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

This is better fit for the purpose!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [10]:
\n
\n
\n
def magical_calculation():\n    try:\n        # here would be the logic of your master piece\n        result = 1 / 0\n    except ZeroDivisionError:\n        return 0\n    except Exception:\n        return None\n    finally:\n        print("This could be something important that should be done every time")\n    return result\n\n\nprint(f"return value: {magical_calculation()}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
This could be something important that should be done every time\nreturn value: 0\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Note: You can also have try-except-else-finally structure. In cases where exception is not raised inside try, else will be executed before finally. If there is an expection, else block is not executed.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Use context managers when possible

One use case example is file I/O.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Don't play with files like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [11]:
\n
\n
\n
try:\n    some_file = open("tmp.txt", "w")\n    print(f"the file is now open: {not some_file.closed}")\n\n    # here would be some logic\n\nfinally:\n    some_file.close()\n    print(f"now it's closed: {some_file.closed}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
the file is now open: True\nnow it's closed: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Use context manager instead!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [12]:
\n
\n
\n
with open("tmp.txt", "w") as some_file:\n    print(f"the file is now open: {not some_file.closed}")\n\n    # here would be some logic\n\nprint(f"now it's closed: {some_file.closed}")\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
the file is now open: True\nnow it's closed: True\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

It's also easy to implement one yourself.

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [13]:
\n
\n
\n
from contextlib import contextmanager\n\n\n@contextmanager\ndef my_context():\n    print("Entering to my context")\n    yield\n    print("Exiting my context")\n\n\ndef do_stuff():\n    with my_context():\n        print("Doing stuff")\n\n    print("Doing some stuff outside my context")\n\n\ndo_stuff()\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
Entering to my context\nDoing stuff\nExiting my context\nDoing some stuff outside my context\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

min() & max()

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [14]:
\n
\n
\n
secret_data = (1, 2, 5, 99, 8, -9)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n
\n
\n
\n
\n

No need to bake it yourself.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [15]:
\n
\n
\n
max_value = 0\nfor val in secret_data:\n    if val > max_value:\n        max_value = val\nprint(max_value)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
99\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Use builtin functionality instead!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [16]:
\n
\n
\n
max_value = max(secret_data)\nprint(max_value)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
99\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

contextlib.suppress - ignoring exceptions

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

If there's a potential exception that is ok, don't handle it like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [17]:
\n
\n
\n
value = 0\ntry:\n    value = 1 / 0  # just for demonstrating purposes\nexcept ZeroDivisionError:\n    pass\n\nprint(value)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Do it like this instead!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [18]:
\n
\n
\n
from contextlib import suppress\n\nvalue = 0\nwith suppress(ZeroDivisionError):\n    value = 1 / 0  # just for demonstrating purposes\n\nprint(value)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
0\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Properties instead of getter/setter methods

\n
\n
\n
\n
\n
\n
\n
\n
\n
\n
\n

Instead of doing something like this.

\n\n
\n
\n
\n
\n
\n
\n
\n
\n
In [19]:
\n
\n
\n
class Person:\n    def __init__(self, first_name, last_name):\n        self.first_name = first_name\n        self.last_name = last_name\n\n    def get_full_name(self):\n        return f"{self.first_name} {self.last_name}"\n\n    def set_full_name(self, full_name):\n        parts = full_name.split()\n        if len(parts) != 2:\n            raise ValueError("Sorry, too difficult name")\n\n        self.first_name, self.last_name = parts\n\n\np = Person("John", "Doe")\nprint(p.get_full_name())\np.set_full_name("Lisa Doe")\nprint(p.get_full_name())\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John Doe\nLisa Doe\n
\n
\n
\n\n
\n\n
\n\n
\n
\n
\n
\n
\n
\n
\n

Prefer properties!

\n
\n
\n
\n
\n
\n
\n
\n
\n
In [20]:
\n
\n
\n
class Person:\n    def __init__(self, first_name, last_name):\n        self.first_name = first_name\n        self.last_name = last_name\n\n    @property\n    def full_name(self):\n        return f"{self.first_name} {self.last_name}"\n\n    @full_name.setter\n    def full_name(self, name):\n        parts = name.split()\n        if len(parts) != 2:\n            raise ValueError("Sorry, too difficult name")\n\n        self.first_name, self.last_name = parts\n\n\np = Person("John", "Doe")\nprint(p.full_name)\np.full_name = "Lisa Doe"\nprint(p.full_name)\n
\n\n
\n
\n
\n
\n\n
\n
\n
\n\n\n
\n
\n \n
\n\n\n
\n
John Doe\nLisa Doe\n
\n
\n
\n\n
\n\n
\n\n
\n\n\n\n\n\n\n\n\n\n" }, { "path": "notebooks/intermediate/notebooks/01_best_practices.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Best practices in development\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## One virtual environment per project\\n\",\n \"\\n\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* Isolation\\n\",\n \"* Different projects have different dependency versions\\n\",\n \"* You don't want to mess up the system Python\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling\\n\",\n \"`poetry` is currently the recommended tool for dependency management but [\\\"consider other tools such as pip when poetry does not meet your use case\\\"](https://packaging.python.org/guides/tool-recommendations/#application-dependency-management). If `poetry` doesn't fit your use case, I recommend using `virtualenvwrapper` for managing virtual environments and `pip` for package management. On the other hand, if you're working on only a couple of projects, built-in [`venv`](https://docs.python.org/3/library/venv.html) will do just fine.\\n\",\n \"#### [`poetry`](https://python-poetry.org/docs/)\\n\",\n \"* Basically combines `pip`, `virtualenv`, and packaging facilities under single CLI\\n\",\n \"* [pyproject.toml](https://python-poetry.org/docs/pyproject/) which replaces the need for requirements.txt and requirements-dev.txt \\n\",\n \"* poetry.lock which pins dependencies, this means deterministic builds\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`virtualenvwrapper`](https://virtualenvwrapper.readthedocs.io/en/latest/)\\n\",\n \"* If you are using Windows command prompt: [`virtualenvwrapper-win`](https://pypi.org/project/virtualenvwrapper-win/)\\n\",\n \"* Like the name suggests, a wrapper around [`virtualenv`](https://pypi.org/project/virtualenv/)\\n\",\n \"* Eases the workflow for creating, deleting, and (de)activating your virtual environments\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`pyenv`](https://github.com/pyenv/pyenv)\\n\",\n \"* Easily change global / per project Python version \\n\",\n \"* Also a tool for installing different Python versions (also different runtimes available, e.g. [PyPy](https://pypy.org/))\\n\",\n \"* Useful if you'll need to work with different Python versions\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Test your code\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* No surprises (especially in production)\\n\",\n \"* Make sure that everything works as expected\\n\",\n \"* Make sure that old stuff works as expected after introducing new features (regression)\\n\",\n \"* Tests give you confidence while refactoring\\n\",\n \"* Good tests demonstrate the use cases of application, i.e. they also document the implementation \\n\",\n \"* ...\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling\\n\",\n \"#### [`pytest`](https://docs.pytest.org/en/latest/)\\n\",\n \"There's [`unittest`](https://docs.python.org/3/library/unittest.html) module in Python Standard Library but the go-to test runner nowadays is definitely `pytest`.\\n\",\n \"\\n\",\n \"Some reasons to use `pytest`:\\n\",\n \"* [`fixtures`](https://docs.pytest.org/en/latest/fixture.html#fixture) for writing reusable testing code\\n\",\n \"* [`markers`](https://docs.pytest.org/en/latest/example/markers.html) for splitting tests to different groups (e.g. smoke, run only on CI machine, etc) or skipping tests in certain conditions\\n\",\n \"* [Automatic test discovery](https://docs.pytest.org/en/latest/goodpractices.html#test-discovery)\\n\",\n \"* [Configurability](https://docs.pytest.org/en/latest/customize.html)\\n\",\n \"* Active development of plugins, to mention a few:\\n\",\n \" * [`pytest-cov`](https://pytest-cov.readthedocs.io/en/latest/) for coverage reporting\\n\",\n \" * [`pytest-xdist`](https://github.com/pytest-dev/pytest-xdist) for speeding up test suit run time with parallelization\\n\",\n \" * see [complete list](https://github.com/pytest-dev) of plugins maintained by `pytest`\\n\",\n \"* Ease of [writing own plugins](https://docs.pytest.org/en/latest/writing_plugins.html)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`tox`](https://tox.readthedocs.io/en/latest/)\\n\",\n \"`tox` makes it simple to test your code against different Python interpreter/runtime and dependency versions. This is important when you're writing software which should support different Python versions, which is usually the case with library-like packages. On the other hand, if you're developing, say, a web application which will be deployed to a known target platform, testing against multiple different versions is usually not necessary. However, `tox` makes it also possible to configure, for example, linting as part of `tox` run. Thus, `tox` may simplify the development workflow significantly by wrapping multiple different operations under a single command.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Write high quality code\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* Easy to read\\n\",\n \"* Better maintainability\\n\",\n \"* Better quality == less bugs\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import this\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling - code formatters\\n\",\n \"[PEP8](https://www.python.org/dev/peps/pep-0008/?) (see also [\\\"for humans version\\\"](https://pep8.org/)) describes the style guidelines for Python code, you should follow them. Luckily, there are awesome tools that handle this for you while you focus on writing code, not formatting it.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`black`](https://black.readthedocs.io/en/stable/)\\n\",\n \"* This is the go-to formatter of the Python community\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling - linters\\n\",\n \"Automatic code formatting is great but in addition to that, you should use static analyzer (linter) to detect potential pitfalls in your code.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`ruff`](https://beta.ruff.rs/docs/)\\n\",\n \"* Most comprehensive linter. As a bonus, it's extremely fast.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling - pre-commit\\n\",\n \"#### [`pre-commit`](https://pre-commit.com/)\\n\",\n \"Ideally, all project contributors should follow the best practices of the project, let it be e.g. respecting PEP8 or making sure there's no linting errors or security vulnerabilities in their change sets. However, as code formatters and linters are (mainly) local tools, this can not be guaranteed. `pre-commit` let's you configure (.pre-commit-config.yaml file) a set of hooks that will be run as pre actions to a commit/push. After a developer has called once `pre-commit install`, these hooks will be then automatically ran prior each commit/push.\\n\",\n \"* Run formatting before commit\\n\",\n \"* Fail the commit in case linting errors\\n\",\n \"* Even exercise the test suite before the code ends up to remote (might be time consuming in most scenarios though)\\n\",\n \"* Easy to configure [your own hooks](https://pre-commit.com/#new-hooks) \\n\",\n \"* And use the [existing ones](https://github.com/pre-commit/pre-commit-hooks)\\n\",\n \"* There's also [pre-push option](https://pre-commit.com/#pre-commit-during-push)\\n\",\n \"* Written in Python but supports also other languages, such as Ruby, Go, and Rust\\n\",\n \"* Less failed CI builds!\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Structure your code and projects\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* Package and module structure gives an overview about the project\\n\",\n \"* Modular design == better reusability\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### How\\n\",\n \"Some general guidelines:\\n\",\n \"* Don't put too much stuff into one module\\n\",\n \"* Split project into packages\\n\",\n \"* Be consistent with your naming conventions\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"A few words about structuring your projects. If you're developing, say, a relative big business application, it makes sense to separate some of the non-core business logic packages into a separate project and publish that as separate package. This way the \\\"main\\\" repository doesn't get bloated and it's more approachable for newcomers. Additionally, there's a change that you (or someone else) can easily reuse this \\\"separated\\\" package in the future, which is often the case e.g. for different kinds of utility functionalities. \\n\",\n \"\\n\",\n \"Let's take a practical example. If your team has two different applications which interact with the same third party, it's beneficial to implement a separate client library for communication with it. This way a change is needed only in one place (in the client library) if the third party decides to make a backwards incompatible change in their API. \"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling\\n\",\n \"#### [`cookiecutter`](https://cookiecutter.readthedocs.io/en/latest/)\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Cookiecutter is a tool which let's you create projects from predefined templates. \\n\",\n \"\\n\",\n \"* Rapid set-up of new projects, no need to copy paste from existing ones\\n\",\n \"* Consistent development practices across all projects (project structure as well as e.g. `pre-commit`, `tox`, and CI configuration)\\n\",\n \"* You can create one yourself or use some of the [existing ones](https://cookiecutter.readthedocs.io/en/latest/readme.html#python)\\n\",\n \"* Written in Python but is applicable for non-Python projects as well, even non-programming related directory and file structures\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Use continuous integration and deployment\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"CI & CD belong to the best practices of software development without controversy, no matter what is the technology stack used for development. From Python point of view, CI is the place where we want to make sure that the other best practices described above are followed. For example, in bigger projects, it may not be even practical/possible to run the full test suite on developer's machine.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* Make sure the tests pass\\n\",\n \"* CI is the place where it's possible to run also some time consuming tests which the impatient developers prefer to skip on their local machines\\n\",\n \"* Make sure there's no linting errors\\n\",\n \"* Ideally, the place to test against all target versions and platforms\\n\",\n \"* Overall, CI is the last resort for automatically ensuring the quality \\n\",\n \"* Manual deployments are time consuming and error-prone, CD is automated and deterministic\\n\",\n \"* You want to automate as much as possible, human time is expensive\\n\",\n \"* Minimize the time required for code reviews - what could be detected with automatic tools, should be detected by using those tools. Human time is expensive. \"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling\\n\",\n \"Tooling depends on which git repository manager option you've chosen and what kind of requirements you have. For example:\\n\",\n \"* [GitHub Actions](https://github.com/features/actions)\\n\",\n \"* If you're using Gitlab, it also has [integrated CI/CD](https://about.gitlab.com/features/gitlab-ci-cd/)\\n\",\n \"* Same for [BitBucket](https://www.atlassian.com/continuous-delivery/continuous-integration-tutorial)\\n\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Utilize the capabitilies of your editor\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* Efficient and fluent development\\n\",\n \"* There's plenty of tools to make your daily programming easier, why would you not use them\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling\\n\",\n \"As there's a number of different editors and IDEs available, not to mention that everyone has their own preferences, I'll just focus on highlighting some of the features of my favorite IDE, PyCharm, which I highly recommend for Python development.\\n\",\n \"\\n\",\n \"#### [PyCharm](https://www.jetbrains.com/help/pycharm/quick-start-guide.html)\\n\",\n \"* Good integration with `pytest`, e.g. run single tests / test classes / test modules\\n\",\n \"* Git integration (in case you don't like command line)\\n\",\n \"* Easy to configure to use automatic formatting, e.g [`black`](https://github.com/ambv/black#pycharm)\\n\",\n \"* Intuitive searching capabilities\\n\",\n \"* Refactoring features\\n\",\n \"* Debugger\\n\",\n \"* Jupyter Notebook integration\\n\",\n \"* Free community edition already contains all you need\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Use existing solutions\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* Python Standard Library is extensive - and stable!\\n\",\n \"* There are over 150k packages in [PyPI](https://pypi.org/)\\n\",\n \"* Someone has most likely solved the problem you're trying to solve\\n\",\n \"* Spend 5 minutes doing a google research before starting to solve a new problem, e.g. [stackoverflow](https://stackoverflow.com/) is a magical place.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Learn how to debug efficiently\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Why\\n\",\n \"* You won't write completely stable code anyway - impossible looking conditions will occur. \\n\",\n \"* When something is not working as expected, there are plenty of tools out there to help you figure out what's going on. \"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling - debuggers\\n\",\n \"#### [`pdb`](https://docs.python.org/3/library/pdb.html)\\n\",\n \"* Part of the Standard Library\\n\",\n \"* Sufficient for most use cases\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`ipdb`](https://pypi.org/project/ipdb/)\\n\",\n \"* Feature rich `pdb` with similar API\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`pdb++`](https://pypi.org/project/pdbpp/)\\n\",\n \"* Drop-in replacement for `pdb` with additional features\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling - profilers\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`memray`](https://bloomberg.github.io/memray/)\\n\",\n \"* Probably the only memory profiler you'll ever need\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [`py-spy`](https://github.com/benfred/py-spy)\\n\",\n \"* Profile running Python program without the need for modifying the source code or restarting the target process\\n\",\n \"* Potential tool for identifying problems of e.g. a web application in production \"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling - runtime error tracking\\n\",\n \"These are especially useful with web applications as you'll get reports - and notifications - of runtime exceptions with full tracebacks and variable values. This information is often enough for identifying the root cause of the problem, which is a huge benefit considering the time required for implementing and deploying the fix.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### [Sentry](https://docs.sentry.io/?platform=python)\\n\",\n \"* Complete stack traces with relevant variable (`locals()`) values\\n\",\n \"* Browser and OS information of the client\\n\",\n \"* Support for other languages as well\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Tooling - misc\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### Use logging instead of prints\\n\",\n \"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"* [`logging`](https://docs.python.org/3/library/logging.html) is part of the Standard Library\\n\",\n \"* With logging you can redirect the output to a file\\n\",\n \"* Logs are usually the first place to look at after an end user reports an issue\\n\",\n \"* You can specify the runtime level - no need to remove the debug prints\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### General guidelines\\n\",\n \"* If you're building applications, use the latest Python.\\n\",\n \"* If you're building libraries, make sure they support also older Python versions. \\n\",\n \"* Develop in branches. Even if you're the only person in the project, branching makes it possible to easily switch between different features / bug fixes.\\n\",\n \"* If you're not developing alone, practice code reviews. It's one of the best ways to learn for both parties.\\n\",\n \"* Document your master pieces\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/notebooks/01_idiomatic_loops.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Idiomatic loops\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Looping in general\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"data = [\\\"John\\\", \\\"Doe\\\", \\\"was\\\", \\\"here\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this. While loops are actually really rarely needed.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"idx = 0\\n\",\n \"while idx < len(data):\\n\",\n \" print(data[idx])\\n\",\n \" idx += 1\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do like this either.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for idx in range(len(data)):\\n\",\n \" print(data[idx])\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for item in data:\\n\",\n \" print(item)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If you need the index as well, you can use enumerate.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for idx, val in enumerate(data):\\n\",\n \" print(f\\\"{idx}: {val}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Looping over a range of numbers\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"i = 0\\n\",\n \"while i < 6:\\n\",\n \" print(i)\\n\",\n \" i += 1\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do this either.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for val in [0, 1, 2, 3, 4, 5]:\\n\",\n \" print(val)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for val in range(6):\\n\",\n \" print(val)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Reversed looping\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"data = [\\\"first\\\", \\\"to\\\", \\\"last\\\", \\\"from\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"This is no good.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"i = len(data) - 1\\n\",\n \"while i >= 0:\\n\",\n \" print(data[i])\\n\",\n \" i -= 1\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for item in reversed(data):\\n\",\n \" print(item)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Looping over __n__ collections simultaneously\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"collection1 = [\\\"a\\\", \\\"b\\\", \\\"c\\\"]\\n\",\n \"collection2 = (10, 20, 30, 40, 50)\\n\",\n \"collection3 = [\\\"John\\\", \\\"Doe\\\", True]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Oh boy, not like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"shortest = len(collection1)\\n\",\n \"if len(collection2) < shortest:\\n\",\n \" shortest = len(collection2)\\n\",\n \"if len(collection3) < shortest:\\n\",\n \" shortest = len(collection3)\\n\",\n \"\\n\",\n \"i = 0\\n\",\n \"while i < shortest:\\n\",\n \" print(collection1[i], collection2[i], collection3[i])\\n\",\n \" i += 1\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"This is getting better but there's even a better way!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"shortest = min(len(collection1), len(collection2), len(collection3))\\n\",\n \"for i in range(shortest):\\n\",\n \" print(collection1[i], collection2[i], collection3[i])\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for first, second, third in zip(collection1, collection2, collection3):\\n\",\n \" print(first, second, third)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"You can also create a dict out of two collections!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = dict(zip(collection1, collection2))\\n\",\n \"print(my_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `for - else` - Checking for a match in a collection\\n\",\n \"Let's say we want to verify a certain condition is met by at least one element in a collection. Let's consider the following relatively naive example where we want to verify that at least one item is \\\"python\\\" (case insensitive) in `data`. If not, we'll raise a ValueError.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"data = [1, 2, 3, \\\"This\\\", \\\"is\\\", \\\"just\\\", \\\"a\\\", \\\"random\\\", \\\"Python\\\", \\\"list\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"found = False\\n\",\n \"for val in data:\\n\",\n \" if str(val).lower() == \\\"python\\\":\\n\",\n \" found = True\\n\",\n \" break\\n\",\n \"if not found:\\n\",\n \" raise ValueError(\\\"Nope, couldn't find.\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for val in data:\\n\",\n \" if str(val).lower() == \\\"python\\\":\\n\",\n \" break\\n\",\n \"else:\\n\",\n \" raise ValueError(\\\"Nope, couldn't find.\\\")\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/notebooks/01_pytest_fixtures.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Efficient use of `pytest` fixtures\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Required boilerplate for using `pytest` inside notebooks.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# Let's make sure pytest and ipytest packages are installed\\n\",\n \"# ipytest is required for running pytest inside Jupyter notebooks\\n\",\n \"import sys\\n\",\n \"\\n\",\n \"!{sys.executable} -m pip install pytest\\n\",\n \"!{sys.executable} -m pip install ipytest\\n\",\n \"\\n\",\n \"# These are needed for running pytest inside Jupyter notebooks\\n\",\n \"import ipytest\\n\",\n \"\\n\",\n \"ipytest.autoconfig()\\n\",\n \"\\n\",\n \"import pytest\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Parametrizing fixtures\\n\",\n \"Similarly as you can parametrize test functions with `pytest.mark.parametrize`, you can parametrize fixtures:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"PATHS = [\\\"/foo/bar.txt\\\", \\\"/bar/baz.txt\\\"]\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.fixture(params=PATHS)\\n\",\n \"def executable(request):\\n\",\n \" return request.param\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"def test_something_with_executable(executable):\\n\",\n \" print(executable)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`pytest.mark.usefixtures`](https://docs.pytest.org/en/latest/fixture.html#usefixtures)\\n\",\n \"[`pytest.mark.usefixtures`](https://docs.pytest.org/en/latest/fixture.html#usefixtures) is useful especially when you want to use some fixture in a set of tests but you don't need the return value of the fixture.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.fixture\\n\",\n \"def my_fixture():\\n\",\n \" print(\\\"\\\\nmy_fixture is used\\\")\\n\",\n \" \\n\",\n \"\\n\",\n \"@pytest.fixture\\n\",\n \"def other_fixture():\\n\",\n \" return \\\"FOO\\\"\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.mark.usefixtures('my_fixture')\\n\",\n \"class TestMyStuff:\\n\",\n \" def test_somestuff(self):\\n\",\n \" pass\\n\",\n \" \\n\",\n \" def test_some_other_stuff(self, other_fixture):\\n\",\n \" print(f'here we use also other_fixture which returns: {other_fixture}')\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `pytest` [built-in fixtures](https://docs.pytest.org/en/latest/builtin.html#pytest-api-and-builtin-fixtures)\\n\",\n \"Here are a couple of examples of the useful built-in fixtures, you can view all available fixtures by running `pytest --fixtures`.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`monkeypatch`](https://docs.pytest.org/en/latest/reference.html#_pytest.monkeypatch.MonkeyPatch)\\n\",\n \"Built-in [`monkeypatch`](https://docs.pytest.org/en/latest/reference.html#_pytest.monkeypatch.MonkeyPatch) fixture lets you e.g. set environment variables and set/delete attributes of objects. The use cases are similar as with patching/mocking with `unittest.mock.patch`/`unittest.mock.MagicMock` which are part of the Python Standard Library.\\n\",\n \"\\n\",\n \"**Monkeypatching environment variables:**\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import os\\n\",\n \"\\n\",\n \"\\n\",\n \"def get_env_var_or_none(var_name):\\n\",\n \" return os.environ.get(var_name, None)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"def test_get_env_var_or_none_with_valid_env_var(monkeypatch):\\n\",\n \" monkeypatch.setenv('MY_ENV_VAR', 'secret')\\n\",\n \" res = get_env_var_or_none('MY_ENV_VAR')\\n\",\n \" assert res == 'secret'\\n\",\n \" \\n\",\n \"def test_get_env_var_or_none_with_missing_env_var():\\n\",\n \" res = get_env_var_or_none('NOT_EXISTING')\\n\",\n \" assert res is None\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"**Monkeypatching attributes:**\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class SomeClass:\\n\",\n \" some_value = \\\"some value\\\"\\n\",\n \"\\n\",\n \" @staticmethod\\n\",\n \" def tell_the_truth():\\n\",\n \" print(\\\"This is the original truth\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def fake_truth():\\n\",\n \" print(\\\"This is modified truth\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.fixture\\n\",\n \"def fake_some_class(monkeypatch):\\n\",\n \" monkeypatch.setattr(\\\"__main__.SomeClass.some_value\\\", \\\"fake value\\\")\\n\",\n \" monkeypatch.setattr(\\\"__main__.SomeClass.tell_the_truth\\\", fake_truth)\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"def test_some_class(fake_some_class):\\n\",\n \" print(SomeClass.some_value)\\n\",\n \" SomeClass.tell_the_truth()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`tmpdir`](https://docs.pytest.org/en/latest/tmpdir.html#the-tmpdir-fixture)\\n\",\n \"[`tmpdir`](https://docs.pytest.org/en/latest/tmpdir.html#the-tmpdir-fixture) fixture provides functionality for creating temporary files and directories.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def word_count_of_txt_file(file_path):\\n\",\n \" with open(file_path) as f:\\n\",\n \" content = f.read()\\n\",\n \" return len(content.split())\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"def test_word_count(tmpdir):\\n\",\n \" test_file = tmpdir.join('test.txt')\\n\",\n \" test_file.write('This is example content of seven words')\\n\",\n \" res = word_count_of_txt_file(str(test_file)) # str returns the path\\n\",\n \" assert res == 7\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Fixture scope\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"@pytest.fixture(scope=\\\"function\\\")\\n\",\n \"def func_fixture():\\n\",\n \" print(\\\"\\\\nfunc\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.fixture(scope=\\\"module\\\")\\n\",\n \"def module_fixture():\\n\",\n \" print(\\\"\\\\nmodule\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"@pytest.fixture(scope=\\\"session\\\")\\n\",\n \"def session_fixture():\\n\",\n \" print(\\\"\\\\nsession\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"def test_something(func_fixture, module_fixture, session_fixture):\\n\",\n \" pass\\n\",\n \"\\n\",\n \"def test_something_else(func_fixture, module_fixture, session_fixture):\\n\",\n \" pass\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Setup-teardown behaviour\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"@pytest.fixture\\n\",\n \"def some_fixture():\\n\",\n \" print(\\\"some_fixture is run now\\\")\\n\",\n \" yield \\\"some magical value\\\"\\n\",\n \" print(\\\"\\\\nthis will be run after test execution, you can do e.g. some clean up here\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"def test_something(some_fixture):\\n\",\n \" print('running test_something')\\n\",\n \" assert some_fixture == 'some magical value'\\n\",\n \" print('test ends here')\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Using fixtures automatically\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"@pytest.fixture(autouse=True)\\n\",\n \"def my_fixture():\\n\",\n \" print(\\\"\\\\nusing my_fixture\\\")\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"%%ipytest -s\\n\",\n \"\\n\",\n \"def test_1():\\n\",\n \" pass\\n\",\n \" \\n\",\n \"def test_2():\\n\",\n \" pass\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/notebooks/01_std_lib2.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Goodies of the [Python Standard Library](https://docs.python.org/3/library/#the-python-standard-library)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`json`](https://docs.python.org/3/library/json.html#module-json) for encoding and decoding JSON\\n\",\n \"Because the web is filled with JSON nowadays and the good days of xml are gone.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"data = {\\\"b\\\": True, \\\"a\\\": 1, \\\"nested\\\": {\\\"foo\\\": \\\"bar\\\"}, \\\"c\\\": None, \\\"some_list\\\": [1, 2, 3]}\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Encoding\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import json\\n\",\n \"\\n\",\n \"json_data = json.dumps(data)\\n\",\n \"print(f\\\"type: {type(json_data)} data: {json_data}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Decoding\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"decoded = json.loads(json_data)\\n\",\n \"print(f\\\"type: {type(decoded)} data: {decoded}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`unittest.mock`](https://docs.python.org/3/library/unittest.mock.html#module-unittest.mock)\\n\",\n \"Although `pytest` is the preferred testing framework, `unittest.mock` module offers some goodies that are helpful also in pytest test cases. Mocking and patching are generally useful for \\\"faking\\\" some parts of the logic/state of the software under test. Common use cases are, for example, patching parts of code that interact with 3rd parties (e.g. some web services).\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`MagicMock`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.MagicMock)\\n\",\n \"\\n\",\n \"In general, [Mocks](https://en.wikipedia.org/wiki/Mock_object) are simulated objects that replace the functionality/state of a real world object in a controlled way. Thus, they are especially useful in tests for mimicing some behavior of a specific part of the implementation under test.\\n\",\n \"\\n\",\n \"There is also a [`Mock`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.Mock) class in the Python Standard Library but you usually want to use [`MagicMock`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.MagicMock) which is a subclass of `Mock`. `MagicMock` provides default implementation for the most of the magic methods (e.g. `__setitem__()` and `__getitem__()`)\\n\",\n \"\\n\",\n \"A potential use case could be something like this:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"import random\\n\",\n \"\\n\",\n \"\\n\",\n \"class Client:\\n\",\n \" def __init__(self, url, username, password):\\n\",\n \" self.url = url\\n\",\n \" self.creds = (username, password)\\n\",\n \"\\n\",\n \" def fetch_some_data(self):\\n\",\n \" print(\\n\",\n \" \\\"Here we could for example fetch data from 3rd party API and return the data.\\\"\\n\",\n \" )\\n\",\n \" print(\\\"Now we will just return some random number between 1-100.\\\")\\n\",\n \" return random.randint(1, 100)\\n\",\n \"\\n\",\n \"\\n\",\n \"class MyApplication:\\n\",\n \" def __init__(self):\\n\",\n \" self.client = Client(\\n\",\n \" url=\\\"https://somewhere/api\\\", username=\\\"John Doe\\\", password=\\\"secret123?\\\"\\n\",\n \" )\\n\",\n \"\\n\",\n \" def do_something_fancy(self):\\n\",\n \" data = self.client.fetch_some_data()\\n\",\n \" return data ** (1 / 2) # let's return a square root just for example\\n\",\n \"\\n\",\n \"\\n\",\n \"####################\\n\",\n \"# In the test module:\\n\",\n \"\\n\",\n \"from unittest.mock import MagicMock\\n\",\n \"\\n\",\n \"# Inside a test case:\\n\",\n \"app = MyApplication()\\n\",\n \"app.client = MagicMock() # Mock the client\\n\",\n \"app.client.fetch_some_data.return_value = 4 # Set controlled behaviour\\n\",\n \"result = app.do_something_fancy()\\n\",\n \"assert result == 2\\n\",\n \"print(\\\"All good, woop woop!\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`patch`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.patch)\\n\",\n \"The use cases of [`patch`](https://docs.python.org/3/library/unittest.mock.html#unittest.mock.patch) are pretty similar to `MacigMock`. The biggest difference is that `patch` is used as a context manager or a decorator. Object to be patched is given as an argument for `patch`. In addition, you can provide additional object as a second argument (`new`) which will replace the original one. In case the `new` is omitted, `MagicMock` will be used by default.\\n\",\n \"\\n\",\n \"Let's see how the example above would look like with `patch`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# In the test module:\\n\",\n \"\\n\",\n \"from unittest.mock import patch\\n\",\n \"\\n\",\n \"# Inside a test case:\\n\",\n \"app = MyApplication()\\n\",\n \"with patch(\\\"__main__.app.client\\\") as patched_client: # Patch the client\\n\",\n \" patched_client.fetch_some_data.return_value = 4 # Set controlled behaviour\\n\",\n \" result = app.do_something_fancy()\\n\",\n \" assert result == 2\\n\",\n \" print(\\\"All good, woop woop!\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"The same but with a function decorator instead of a context manager. Note that here we are patching the whole `Client` class, not just the `client` instance variable of `app`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from unittest.mock import patch\\n\",\n \"\\n\",\n \"\\n\",\n \"@patch(\\\"__main__.Client\\\") # Patch the Client\\n\",\n \"def test_do_something_fancy(client_cls):\\n\",\n \" client_cls().fetch_some_data.return_value = 4 # Set controlled behaviour\\n\",\n \" app = MyApplication()\\n\",\n \" result = app.do_something_fancy()\\n\",\n \" assert result == 2\\n\",\n \" print(\\\"All good, woop woop!\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"test_do_something_fancy() # This is just for the sake of example\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## [`collections`](https://docs.python.org/3/library/collections.html#module-collections)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`namedtuple`](https://docs.python.org/3/library/collections.html#collections.namedtuple)\\n\",\n \"A great helper for creating more readable and self documenting code.\\n\",\n \"\\n\",\n \"`namedtuple` is a function that returns a tuple whose fields have names and also the tuple itself has a name (just like classes and their instance variables). Potential use cases include storing data which should be immutable. If you can use Python 3.7 or newer, you may want to take a look at [`dataclasses`](https://docs.python.org/3/library/dataclasses.html#module-dataclasses) as well. \"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from collections import namedtuple\\n\",\n \"\\n\",\n \"Person = namedtuple(\\\"Person\\\", [\\\"name\\\", \\\"age\\\", \\\"is_gangster\\\"])\\n\",\n \"\\n\",\n \"# instance creation is similar to classes\\n\",\n \"john = Person(\\\"John Doe\\\", 83, True)\\n\",\n \"lisa = Person(\\\"Lis Doe\\\", age=77, is_gangster=False)\\n\",\n \"\\n\",\n \"print(john, lisa)\\n\",\n \"print(f\\\"Is John a gangster: {john.is_gangster}\\\")\\n\",\n \"\\n\",\n \"# tuples are immutable, thus you can't do this\\n\",\n \"# john.is_gangster = False\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`Counter`](https://docs.python.org/3/library/collections.html#collections.Counter)\\n\",\n \"For counting the occurences of elements in a collection.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from collections import Counter\\n\",\n \"\\n\",\n \"data = [1, 2, 3, 1, 2, 4, 5, 6, 2]\\n\",\n \"\\n\",\n \"counter = Counter(data)\\n\",\n \"print(f\\\"type: {type(counter)}, counter: {counter}\\\")\\n\",\n \"\\n\",\n \"print(f\\\"count of twos: {counter[2]}\\\")\\n\",\n \"print(f\\\"count of tens: {counter[10]}\\\") # zero for non existing\\n\",\n \"\\n\",\n \"print(f\\\"counter is a dict: {isinstance(counter, dict)}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### [`defaultdict`](https://docs.python.org/3/library/collections.html#collections.defaultdict)\\n\",\n \"For cleaner code for populating dictionaries.\\n\",\n \"\\n\",\n \"Let's first see how you could use a normal `dict`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"data = (1, 2, 3, 4, 3, 2, 5, 6, 7)\\n\",\n \"\\n\",\n \"my_dict = {}\\n\",\n \"for val in data:\\n\",\n \" if val % 2:\\n\",\n \" if not \\\"odd\\\" in my_dict:\\n\",\n \" my_dict[\\\"odd\\\"] = []\\n\",\n \" my_dict[\\\"odd\\\"].append(val)\\n\",\n \" else:\\n\",\n \" if not \\\"even\\\" in my_dict:\\n\",\n \" my_dict[\\\"even\\\"] = []\\n\",\n \" my_dict[\\\"even\\\"].append(val)\\n\",\n \"\\n\",\n \"print(my_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"With `defaultdict`:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from collections import defaultdict\\n\",\n \"\\n\",\n \"my_dict = defaultdict(list)\\n\",\n \"for val in data:\\n\",\n \" if val % 2:\\n\",\n \" my_dict[\\\"odd\\\"].append(val)\\n\",\n \" else:\\n\",\n \" my_dict[\\\"even\\\"].append(val)\\n\",\n \"print(my_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"In the above example, `defaultdict` makes sure that a fresh `list` is automatically initialized as a value when a new key is added.\\n\",\n \"\\n\",\n \"Here's another example with `int` as a default.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = defaultdict(int)\\n\",\n \"for val in data:\\n\",\n \" if val % 2:\\n\",\n \" my_dict[\\\"odd_count\\\"] += 1\\n\",\n \" else:\\n\",\n \" my_dict[\\\"even_count\\\"] += 1\\n\",\n \"print(my_dict)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/notebooks/02_idiomatic_dicts.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Idiomatic dictionaries\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `get` - default value of a non existing key while accessing\\n\",\n \"Especially handy if you're unsure about the presence of a key.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"a\\\": 1, \\\"b\\\": 2, \\\"c\\\": 3}\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if \\\"g\\\" in my_dict:\\n\",\n \" value = my_dict[\\\"g\\\"]\\n\",\n \"else:\\n\",\n \" value = \\\"some default value\\\"\\n\",\n \"print(value)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Or like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"try:\\n\",\n \" value = my_dict[\\\"g\\\"]\\n\",\n \"except KeyError:\\n\",\n \" value = \\\"some default value\\\"\\n\",\n \"print(value)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"value = my_dict.get(\\\"g\\\", \\\"some default value\\\")\\n\",\n \"print(value)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Note that if you don't provide the default value for `get`, the return value will be `None` if the key is not present in the dictionary\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"value = my_dict.get(\\\"g\\\")\\n\",\n \"print(value is None)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `setdefault` - same as `get` but also sets the value if not present\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"a\\\": 1, \\\"b\\\": 2, \\\"c\\\": 3}\\n\",\n \"\\n\",\n \"key = \\\"g\\\"\\n\",\n \"if key in my_dict:\\n\",\n \" value = my_dict[key]\\n\",\n \"else:\\n\",\n \" value = \\\"some default value\\\"\\n\",\n \" my_dict[key] = value\\n\",\n \"\\n\",\n \"print(value)\\n\",\n \"print(my_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Let's do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"a\\\": 1, \\\"b\\\": 2, \\\"c\\\": 3}\\n\",\n \"\\n\",\n \"key = \\\"g\\\"\\n\",\n \"value = my_dict.setdefault(key, \\\"some default value\\\")\\n\",\n \"\\n\",\n \"print(value)\\n\",\n \"print(my_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Comprehensions\\n\",\n \"Let's say we have a collection of numbers and we want to store those as a dictionary where the number is key and it's square is the value.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"numbers = (1, 5, 10)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"squares = {}\\n\",\n \"for num in numbers:\\n\",\n \" squares[num] = num**2\\n\",\n \"print(squares)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"squares = {num: num**2 for num in numbers}\\n\",\n \"print(squares)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Another example\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"keys = (\\\"a\\\", \\\"b\\\", \\\"c\\\")\\n\",\n \"values = [True, 100, \\\"John Doe\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {}\\n\",\n \"for idx, key in enumerate(keys):\\n\",\n \" my_dict[key] = values[idx]\\n\",\n \"print(my_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {k: v for k, v in zip(keys, values)}\\n\",\n \"print(my_dict)\\n\",\n \"\\n\",\n \"# Or even like this:\\n\",\n \"my_dict2 = dict(zip(keys, values))\\n\",\n \"\\n\",\n \"assert my_dict2 == my_dict\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Looping\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_dict = {\\\"age\\\": 83, \\\"is gangster\\\": True, \\\"name\\\": \\\"John Doe\\\"}\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for key in my_dict:\\n\",\n \" val = my_dict[key]\\n\",\n \" print(f\\\"key: {key:15s} value: {val}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"for key, val in my_dict.items():\\n\",\n \" print(f\\\"key: {key:15s} value: {val}\\\")\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.5.4\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/notebooks/03_idiomatic_misc1.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Idiomatic Python - miscellaneous part 1\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Comprehensions\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"original_data = (1, 2, 3, 4)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# list\\n\",\n \"square_roots_list = []\\n\",\n \"for val in original_data:\\n\",\n \" square_root = val ** (1 / 2)\\n\",\n \" square_roots_list.append(square_root)\\n\",\n \"print(square_roots_list)\\n\",\n \"\\n\",\n \"# set\\n\",\n \"square_roots_set = set()\\n\",\n \"for val in original_data:\\n\",\n \" square_root = val ** (1 / 2)\\n\",\n \" square_roots_set.add(square_root)\\n\",\n \"print(square_roots_set)\\n\",\n \"\\n\",\n \"# dict\\n\",\n \"square_roots_dict = {}\\n\",\n \"for val in original_data:\\n\",\n \" square_root = val ** (1 / 2)\\n\",\n \" square_roots_dict[val] = square_root\\n\",\n \"print(square_roots_dict)\\n\",\n \"\\n\",\n \"# dict with a condition\\n\",\n \"integer_square_roots_dict = {}\\n\",\n \"for val in original_data:\\n\",\n \" square_root = val ** (1 / 2)\\n\",\n \" if square_root.is_integer():\\n\",\n \" integer_square_roots_dict[val] = square_root\\n\",\n \"print(integer_square_roots_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Note: in case you're using 2.X version of Python for some reason, the result of `1/2` is `0` instead of `0.5`. \"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Use comprehensions!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"square_roots_list = [val ** (1 / 2) for val in original_data]\\n\",\n \"print(square_roots_list)\\n\",\n \"\\n\",\n \"square_roots_set = {val ** (1 / 2) for val in original_data}\\n\",\n \"print(square_roots_set)\\n\",\n \"\\n\",\n \"square_roots_dict = {val: val ** (1 / 2) for val in original_data}\\n\",\n \"print(square_roots_dict)\\n\",\n \"\\n\",\n \"integer_square_roots_dict = {\\n\",\n \" val: val ** (1 / 2) for val in original_data if (val ** (1 / 2)).is_integer()\\n\",\n \"}\\n\",\n \"print(integer_square_roots_dict)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Using `in` for checking presence of an element in a collection\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"name = \\\"John Doe\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if name == \\\"John\\\" or name == \\\"Doe\\\" or name == \\\"John Doe\\\":\\n\",\n \" print(\\\"This seems to be our guy\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if name in (\\\"John\\\", \\\"Doe\\\", \\\"John Doe\\\"):\\n\",\n \" print(\\\"This seems to be our guy\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Chained comparisons\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"a, b, c, d = 1, 2, 3, 4\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if b > a and c > b and d > c:\\n\",\n \" print(\\\"from lowest to highest: a, b, c, d\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if a < b < c < d:\\n\",\n \" print(\\\"from lowest to highest: a, b, c, d\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Falsy/truthy values\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# These are falsy\\n\",\n \"my_list = []\\n\",\n \"my_dict = {}\\n\",\n \"my_set = set()\\n\",\n \"my_tuple = tuple()\\n\",\n \"zero = 0\\n\",\n \"false = False\\n\",\n \"none = None\\n\",\n \"my_str = \\\"\\\"\\n\",\n \"\\n\",\n \"# Basically the rest are truthy\\n\",\n \"# for example:\\n\",\n \"my_second_list = [\\\"foo\\\"]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if len(my_list) == 0:\\n\",\n \" print(\\\"Empty list is so empty\\\")\\n\",\n \"\\n\",\n \"if not len(my_dict):\\n\",\n \" print(\\\"Empty dict is also very empty\\\")\\n\",\n \"\\n\",\n \"if not len(my_set) and not len(my_tuple):\\n\",\n \" print(\\\"Same goes for sets and tuples\\\")\\n\",\n \"\\n\",\n \"if not bool(zero) and not bool(false) and not bool(none) and len(my_str) == 0:\\n\",\n \" print(\\\"These are also falsy\\\")\\n\",\n \"\\n\",\n \"if len(my_second_list) > 0:\\n\",\n \" print(\\\"This should be true\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### This is much better!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"if not my_list:\\n\",\n \" print(\\\"Empty list is so empty\\\")\\n\",\n \"\\n\",\n \"if not my_dict:\\n\",\n \" print(\\\"Empty dict is also very empty\\\")\\n\",\n \"\\n\",\n \"if not my_set and not my_tuple:\\n\",\n \" print(\\\"Same goes for sets and tuples\\\")\\n\",\n \"\\n\",\n \"if not zero and not false and not none and not my_str:\\n\",\n \" print(\\\"These are also falsy\\\")\\n\",\n \"\\n\",\n \"if my_second_list:\\n\",\n \" print(\\\"This should be true\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `any` & `all`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"example_collection = [\\\"a\\\", True, \\\"Python is cool\\\", 123, 0]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"any_value_truthy = True\\n\",\n \"for val in example_collection:\\n\",\n \" if val:\\n\",\n \" any_value_truthy = True\\n\",\n \" break\\n\",\n \"\\n\",\n \"all_values_truthy = True\\n\",\n \"for val in example_collection:\\n\",\n \" if not val:\\n\",\n \" all_values_truthy = False\\n\",\n \" break\\n\",\n \"\\n\",\n \"print(f\\\"any truthy: {any_value_truthy}, all truthy: {all_values_truthy}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"any_value_truthy = any(example_collection)\\n\",\n \"all_values_truthy = all(example_collection)\\n\",\n \"print(f\\\"any truthy: {any_value_truthy}, all truthy: {all_values_truthy}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Pythonic substitute for ternary operator\\n\",\n \"Many other programming languages have a ternary operator: `?`. A common use case for the ternary operator is to assign a certain value to a variable based on some condition. In other words, it could be used like this:\\n\",\n \"```\\n\",\n \"variable = some_condition ? some_value : some_other_value\\n\",\n \"```\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Instead of doing this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"some_condition = True # just a dummy condition\\n\",\n \"\\n\",\n \"if some_condition:\\n\",\n \" variable = \\\"John\\\"\\n\",\n \"else:\\n\",\n \" variable = \\\"Doe\\\"\\n\",\n \"print(variable)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### You can do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"variable = \\\"John\\\" if some_condition else \\\"Doe\\\"\\n\",\n \"print(variable)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Function keywords arguments\\n\",\n \"For better readability and maintainability.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def show_person_details(name, is_gangster, is_hacker, age):\\n\",\n \" print(f\\\"name: {name}, gangster: {is_gangster}, hacker: {is_hacker}, age: {age}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"This is not good. It's hard to tell what `True`, `False` and `83` refer here if you are not familiar with the signature of the `show_person_details` function.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"show_person_details(\\\"John Doe\\\", True, False, 83)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### This is much better!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"show_person_details(\\\"John Doe\\\", is_gangster=True, is_hacker=False, age=83)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"#### Extra: keyword only arguments after `*`\\n\",\n \"This might be useful for example if the signature of the function is likely to change in the future. For example, if there's even a slight chance that one of the arguments may be dropped during the future development, consider using `*`.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def func_with_loads_of_args(arg1, *, arg2=None, arg3=None, arg4=None, arg5=\\\"boom\\\"):\\n\",\n \" pass\\n\",\n \"\\n\",\n \"\\n\",\n \"# This won't work because only keyword arguments allowed after *\\n\",\n \"# func_with_loads_of_args('John Doe', 1, 2)\\n\",\n \"\\n\",\n \"# This is ok\\n\",\n \"func_with_loads_of_args(\\\"John Doe\\\", arg4=\\\"foo\\\", arg5=\\\"bar\\\", arg2=\\\"foo bar\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Multiple assigment\\n\",\n \"Let's say we want to swap the values of two variables.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# original values\\n\",\n \"a = 1\\n\",\n \"b = 2\\n\",\n \"\\n\",\n \"# swap\\n\",\n \"tmp = a\\n\",\n \"a = b\\n\",\n \"b = tmp\\n\",\n \"print(a, b)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# original values\\n\",\n \"a = 1\\n\",\n \"b = 2\\n\",\n \"\\n\",\n \"# swap\\n\",\n \"a, b = b, a\\n\",\n \"print(a, b)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## (Un)packing\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_list = [1, 2, 3, 4, 5, 6]\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do something like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"first = my_list[0]\\n\",\n \"last = my_list[-1]\\n\",\n \"middle = my_list[1:-1]\\n\",\n \"print(first, middle, last)\\n\",\n \"\\n\",\n \"packed = [first] + middle + [last]\\n\",\n \"assert packed == my_list\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### This is the Pythonic way!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"# unpacking\\n\",\n \"first, *middle, last = my_list\\n\",\n \"print(first, middle, last)\\n\",\n \"\\n\",\n \"# packing\\n\",\n \"packed = [first, *middle, last]\\n\",\n \"assert packed == my_list\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "notebooks/intermediate/notebooks/04_idiomatic_misc2.ipynb", "content": "{\n \"cells\": [\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"# Idiomatic Python - miscellaneous part 2\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## String concatenation\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"names = (\\\"John\\\", \\\"Lisa\\\", \\\"Terminator\\\", \\\"Python\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"semicolon_separated = names[0]\\n\",\n \"for name in names[1:]:\\n\",\n \" semicolon_separated += \\\";\\\" + name\\n\",\n \"print(semicolon_separated)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Use `join` instead!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"semicolon_separated = \\\";\\\".join(names)\\n\",\n \"print(semicolon_separated)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `or` in assignments\\n\",\n \"The return value of `a or b`:\\n\",\n \"* `a` if `a` is truthy\\n\",\n \"* `b` otherwise\\n\",\n \"\\n\",\n \"You can take advantage of this e.g. while writing variable assignments.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"a = 0\\n\",\n \"b = None\\n\",\n \"c = \\\"John Doe\\\"\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Instead of doing something like this:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_variable = \\\"default value\\\"\\n\",\n \"if a:\\n\",\n \" my_variable = a\\n\",\n \"elif b:\\n\",\n \" my_variable = b\\n\",\n \"elif c:\\n\",\n \" my_variable = c\\n\",\n \"print(my_variable)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Prefer doing this:\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"my_variable = a or b or c or \\\"default value\\\"\\n\",\n \"print(my_variable)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `try` - `except` - `else`\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't use the following technique for checking if there was exceptions during execution of some block of code.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"exception_occured = False\\n\",\n \"try:\\n\",\n \" # here would be the logic of your master piece\\n\",\n \"\\n\",\n \" bad_calculation = 1 / 0\\n\",\n \"\\n\",\n \"except ValueError as e:\\n\",\n \" print(f\\\"Oh boi, some value error: {e}\\\")\\n\",\n \" exception_occured = True\\n\",\n \"except Exception as e:\\n\",\n \" print(f\\\"Oh boi, something bad happened: {e}\\\")\\n\",\n \" exception_occured = True\\n\",\n \"\\n\",\n \"if not exception_occured:\\n\",\n \" print(\\\"All went well!\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Use this instead!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"try:\\n\",\n \" # here would be the logic of your master piece\\n\",\n \"\\n\",\n \" bad_calculation = 1 / 0\\n\",\n \"\\n\",\n \"except ValueError as e:\\n\",\n \" print(f\\\"Oh boi, some keyerror: {e}\\\")\\n\",\n \"except Exception as e:\\n\",\n \" print(f\\\"Oh boi, something bad happened: {e}\\\")\\n\",\n \"else:\\n\",\n \" print(\\\"All went well!\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `try` - `finally`\\n\",\n \"For scenarios where you want to do something always, even when there are exceptions.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't do it like this\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def magical_calculation():\\n\",\n \" try:\\n\",\n \" # here would be the logic of your master piece\\n\",\n \" result = 1 / 0\\n\",\n \" except ZeroDivisionError:\\n\",\n \" print(\\\"This could be something important that should be done every time\\\")\\n\",\n \" return 0\\n\",\n \" except Exception:\\n\",\n \" print(\\\"This could be something important that should be done every time\\\")\\n\",\n \" return None\\n\",\n \"\\n\",\n \" print(\\\"This could be something important that should be done every time\\\")\\n\",\n \" return result\\n\",\n \"\\n\",\n \"\\n\",\n \"print(f\\\"return value: {magical_calculation()}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### This is better fit for the purpose!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"def magical_calculation():\\n\",\n \" try:\\n\",\n \" # here would be the logic of your master piece\\n\",\n \" result = 1 / 0\\n\",\n \" except ZeroDivisionError:\\n\",\n \" return 0\\n\",\n \" except Exception:\\n\",\n \" return None\\n\",\n \" finally:\\n\",\n \" print(\\\"This could be something important that should be done every time\\\")\\n\",\n \" return result\\n\",\n \"\\n\",\n \"\\n\",\n \"print(f\\\"return value: {magical_calculation()}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"**Note**: You can also have `try`-`except`-`else`-`finally` structure. In cases where exception is not raised inside `try`, `else` will be executed before `finally`. If there is an expection, `else` block is not executed.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Use context managers when possible\\n\",\n \"One use case example is file I/O.\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Don't play with files like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"try:\\n\",\n \" some_file = open(\\\"tmp.txt\\\", \\\"w\\\")\\n\",\n \" print(f\\\"the file is now open: {not some_file.closed}\\\")\\n\",\n \"\\n\",\n \" # here would be some logic\\n\",\n \"\\n\",\n \"finally:\\n\",\n \" some_file.close()\\n\",\n \" print(f\\\"now it's closed: {some_file.closed}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Use context manager instead!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"with open(\\\"tmp.txt\\\", \\\"w\\\") as some_file:\\n\",\n \" print(f\\\"the file is now open: {not some_file.closed}\\\")\\n\",\n \"\\n\",\n \" # here would be some logic\\n\",\n \"\\n\",\n \"print(f\\\"now it's closed: {some_file.closed}\\\")\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### It's also easy to implement one yourself.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from contextlib import contextmanager\\n\",\n \"\\n\",\n \"\\n\",\n \"@contextmanager\\n\",\n \"def my_context():\\n\",\n \" print(\\\"Entering to my context\\\")\\n\",\n \" yield\\n\",\n \" print(\\\"Exiting my context\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"def do_stuff():\\n\",\n \" with my_context():\\n\",\n \" print(\\\"Doing stuff\\\")\\n\",\n \"\\n\",\n \" print(\\\"Doing some stuff outside my context\\\")\\n\",\n \"\\n\",\n \"\\n\",\n \"do_stuff()\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `min()` & `max()`\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"secret_data = (1, 2, 5, 99, 8, -9)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"No need to bake it yourself.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"max_value = 0\\n\",\n \"for val in secret_data:\\n\",\n \" if val > max_value:\\n\",\n \" max_value = val\\n\",\n \"print(max_value)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Use builtin functionality instead!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"max_value = max(secret_data)\\n\",\n \"print(max_value)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## `contextlib.suppress` - ignoring exceptions \"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"If there's a potential exception that is ok, don't handle it like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"value = 0\\n\",\n \"try:\\n\",\n \" value = 1 / 0 # just for demonstrating purposes\\n\",\n \"except ZeroDivisionError:\\n\",\n \" pass\\n\",\n \"\\n\",\n \"print(value)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Do it like this instead!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"from contextlib import suppress\\n\",\n \"\\n\",\n \"value = 0\\n\",\n \"with suppress(ZeroDivisionError):\\n\",\n \" value = 1 / 0 # just for demonstrating purposes\\n\",\n \"\\n\",\n \"print(value)\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"## Properties instead of getter/setter methods\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"Instead of doing something like this.\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Person:\\n\",\n \" def __init__(self, first_name, last_name):\\n\",\n \" self.first_name = first_name\\n\",\n \" self.last_name = last_name\\n\",\n \"\\n\",\n \" def get_full_name(self):\\n\",\n \" return f\\\"{self.first_name} {self.last_name}\\\"\\n\",\n \"\\n\",\n \" def set_full_name(self, full_name):\\n\",\n \" parts = full_name.split()\\n\",\n \" if len(parts) != 2:\\n\",\n \" raise ValueError(\\\"Sorry, too difficult name\\\")\\n\",\n \"\\n\",\n \" self.first_name, self.last_name = parts\\n\",\n \"\\n\",\n \"\\n\",\n \"p = Person(\\\"John\\\", \\\"Doe\\\")\\n\",\n \"print(p.get_full_name())\\n\",\n \"p.set_full_name(\\\"Lisa Doe\\\")\\n\",\n \"print(p.get_full_name())\"\n ]\n },\n {\n \"cell_type\": \"markdown\",\n \"metadata\": {},\n \"source\": [\n \"### Prefer properties!\"\n ]\n },\n {\n \"cell_type\": \"code\",\n \"execution_count\": null,\n \"metadata\": {},\n \"outputs\": [],\n \"source\": [\n \"class Person:\\n\",\n \" def __init__(self, first_name, last_name):\\n\",\n \" self.first_name = first_name\\n\",\n \" self.last_name = last_name\\n\",\n \"\\n\",\n \" @property\\n\",\n \" def full_name(self):\\n\",\n \" return f\\\"{self.first_name} {self.last_name}\\\"\\n\",\n \"\\n\",\n \" @full_name.setter\\n\",\n \" def full_name(self, name):\\n\",\n \" parts = name.split()\\n\",\n \" if len(parts) != 2:\\n\",\n \" raise ValueError(\\\"Sorry, too difficult name\\\")\\n\",\n \"\\n\",\n \" self.first_name, self.last_name = parts\\n\",\n \"\\n\",\n \"\\n\",\n \"p = Person(\\\"John\\\", \\\"Doe\\\")\\n\",\n \"print(p.full_name)\\n\",\n \"p.full_name = \\\"Lisa Doe\\\"\\n\",\n \"print(p.full_name)\"\n ]\n }\n ],\n \"metadata\": {\n \"kernelspec\": {\n \"display_name\": \"Python 3 (ipykernel)\",\n \"language\": \"python\",\n \"name\": \"python3\"\n },\n \"language_info\": {\n \"codemirror_mode\": {\n \"name\": \"ipython\",\n \"version\": 3\n },\n \"file_extension\": \".py\",\n \"mimetype\": \"text/x-python\",\n \"name\": \"python\",\n \"nbconvert_exporter\": \"python\",\n \"pygments_lexer\": \"ipython3\",\n \"version\": \"3.11.0\"\n }\n },\n \"nbformat\": 4,\n \"nbformat_minor\": 2\n}\n" }, { "path": "pytest.ini", "content": "[pytest]\nnorecursedirs = exercises* .ipynb_checkpoints*" }, { "path": "scripts/notebook_to_html.py", "content": "from pathlib import Path\nimport subprocess\nimport sys\n\n\ndef main():\n path = sys.argv[1]\n if path.strip().lower() == \"all\":\n convert_all_notebooks_to_html()\n else:\n convert_notebook_to_html(path)\n\n\ndef convert_all_notebooks_to_html():\n notebook_dir = Path(__file__).parent.parent / \"notebooks\"\n for directory in (\n notebook_dir / \"beginner\" / \"notebooks\",\n notebook_dir / \"intermediate\" / \"notebooks\",\n ):\n for notebook_path in directory.glob(\"*.ipynb\"):\n convert_notebook_to_html(notebook_path)\n\n\ndef convert_notebook_to_html(notebook_path):\n path = Path(notebook_path)\n if not path.exists():\n raise SystemExit(f\"Invalid path {path}\")\n\n output_dir = path.parent.parent / \"html\"\n\n cmd = f\"jupyter nbconvert --to html --execute --ExecutePreprocessor.timeout=30 --output-dir {output_dir} {path.absolute()}\"\n subprocess.check_call(cmd.split())\n\n\nif __name__ == \"__main__\":\n main()\n" } ]