Add an 'advanced python' section/sections that goes beyond the course content

[Bergam0t]

A place for all the useful things you might otherwise come across some way into your Python journey and go 'I wish I'd known that'

Would need to make it clear that this isn't stuff people need to know at the start - it's the kind of things you should perhaps return to a few months down the line after doing some of the other modules or writing some simple scripts in your organisation.

• debugging strategies
• writing good comments/writing your code in a way that will help you (and other people) to understand it in future
• docstrings
• writing a readme (building a README.md and talking a little about markdown here could get them into good habits ahead of learning about GitHub, and also starts priming them for using the syntax of Quarto)
• type hints
• VSCode extensions for a smoother developer experience
• advice on LLM use (responsible, recording, idea around productive struggle and building good debugging habits, using as junior colleague, using as senior colleague)
• linting (why and how)
• tests (and a brief mention of test driven development)
• connecting to databases (not advanced in quite the same way, but potentially very useful for our cohort)
• using other people's packages responsibly (things to consider when deciding to use a package)
• secure python practices (e.g. avoiding hardcoding secrets)
• building a good requirements.txt (this is something we often get questions about in the project phase)
• automating the running of scripts via e.g. task scheduler
• decorators
• the logging module
• more advanced error handling (I think we currently just use bare except, which works but could be extended on)
• structuring larger pieces of code into multiple files
• packaging code (internal packages - perhaps talk a little about PyPi too?)
• composition vs inheritance and its use cases
• monkey patching, subclassing, wrapping
• pickle, json, and other data export formats beyond csv
• collaborative coding strategies in your organisation (pair programming, good code review)
• refactoring and technical debt
• relative and absolute paths and the pathlib module
• validators (e.g. pydantic)
• interacting with APIs
• maybe move the xlsxwriter stuff from module 8 into here? As ties into creating outputs and automating them.
• key RAP principles