Giters

charlax / python-education

Reading list for ramping up with professional Python

Geek Repo:Geek Repo

Github PK Tool:Github PK Tool

About this list

Items:

  • 🧰 : list of resources
  • 📖 : book
  • 🎞 : video/movie extract/movie
  • 🎤 : slides/presentation
  • 🎧 : podcast
  • 🔧 : tool
  • ⭐️ : must-read

The goal of this documentation is to help you become a productive Python developer.

It assumes that those skills will be used in a professional environment. It includes concrete exercises, because the best way to learn is by doing. It focuses on real-world, applied documentation that will help your programming on a day-to-day basis.

This doc assumes programming knowledge and experience.

If you're also interested in generic programming best practices, I've compiled a list of professional programming resources.

Learning the language

Why learn Python?

Beginner

Here are some free books:

  • Official Tutorial: Python's official doc is really good, highly recommended read.
  • Dive Into Python: much faster introduction to Python, a bit outdated but will get you ramped up really fast, especially if you've learned a number of programming language in the past.

The Python Guide has some other good resources.

If you're coming from another language, read this article about the ten myths of enterprise Python.

If you want to review algorithms at the same time, you can use Problem Solving with Algorithms and Data Structures using Python by Bradley N. Miller, David L. Ranum.

Other resources include (prefer the one listed above):

Intermediate

I wrote some introductory material to advanced Python:

Some other resources:

Articles, videos and presentations

Books

Lists of books:

Podcasts

Writing idiomatic Python

First things first, let's get code style out of the way. Make sure you've read and memorized PEP8 (code style, more readable version here) and PEP257 (docstring style). Those two code styles are applied by almost all major Python applications and libraries. Use flake8, pydocstyle and black to ensure they are applied (check other linters and autofixers below).

What is called "idiomatic Python" might feel magical at first, especially if you don't know Python. I'd recommend getting your hands dirty with some real world Python code. Try to wander around the code, opening random files. Run the tutorial with a debugger to follow the flow and understand what's going on.

  • bottle.py: bottle is a web framework. It's a great resource because it's in all in whole file! Recommended reading. You can even print it.
  • flask: another web framework, one of the best. Reading its code is highly recommended as well.

You can find other ideas on this hacker news thread.

I feel it's more important to understand the vision behind Python's design, than to know specific Python idioms. The Zen of Python will help you understand the fundamental reasoning behind each idiom.

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Learning idiomatic Python:

List of books:

Exercises

The best way to learn is to do.

Code practice websites

Small exercises

Larger projects

  • Build a lock library for Redis.
  • Build a cache library for Redis.
  • Build an API for storing todos
  • Build an API for next bus departure time.
  • Build an ORM for a SQL database.
  • Build a command line parser.
  • Build a template engine.
  • Build a static site generator.
  • Build an HTTP library.
  • Clone one of those games
  • Write a game using pyarcade
  • spandanb/learndb-py: learn database internals by implementing it from scratch.

Reddit's dailyprogrammer subreddit has some good exercises as well.

Another great way to learn Python is by contributing to one of the numerous open source libraries. Coding is not something that is to be learn in isolation, and you'll learn great valuable insights from the code review you'll get from those communities. You can look for tickets (e.g. Github issues) for Python libraries you're using, or find some in the list below, or pick one of the libraries listed in Awesome Python.

Make sure you pick a library where the tickets are not too involved, and where the community is still alive (i.e. there's recent merged pull requests).

My exercises

Topics

Algorithms

Best Practices

Beyond Python (other programming languages)

Boilerplate

Celery

Celery is a distributed async tasks runner.

CLI

Building command line interfaces.

Code Architecture

Concurrency

  • Concurrency with Python: a pretty complete series of articles that goes into threads, functional programming, actor models, CSP, coroutines and data intensive architectures.

Configuration

Debugging

Deployment

See also the more generic Docker section in charlax/professional-programming.

Design patterns

I maintain a list of antipatterns on this repo.

Documentation

Example, inspiration and template packages

By topics:

Exception

File organisation (monorepo, folders, etc.)

Functional programming

Consider checking out the same section on my charlax/professional-programming repo.

Internals

Python behind the scenes series:

Magic methods

Open source Python apps

It's often a good idea to read the Python source code of well-written applications:

Packages (finding and using them)

How to use:

Lists:

Packages (opinionated list)

Here's a short list of great packages:

Some other cool packages:

Packaging (creating your own package)

Parsing

Performance

Stories:

Tools:

  • 🔧 SnakeViz is a browser based graphical viewer for the output of Python’s cProfile module.
  • 🔧 RunSnakeRun is a small GUI utility that allows you to view (Python) cProfile or Profile profiler dumps in a sortable GUI view.
  • 🔧 plasma-umass/scalene: a high-performance, high-precision CPU, GPU, and memory profiler
  • 🔧 pytest-benchmark
  • 🔧 benfred/py-spy: sampling CPU profiler written in Rust for low overhead
  • 🔧 pythonspeed/filprofiler: memory profiler for data processing and scientific computing applications

Preparing for interviews

Quirks and gotchas

Regular expressions (regex)

Security

SQLAlchemy

SQLAlchemy is the de facto standard ORM for Python. It has a unique approach: contrary to most ORM, it tries very hard not to hide the SQL implementation details from you. This is great because it forces you to really understand the underlying DB.

Here is some slightly outdated content that is super useful to fully leverage the library:

Standard library modules

Some little known standard library modules:

  • shelve: Python object persistence

Static analysis of code

Tests

Half of coding time is usually spent writing tests. Yet how to write tests efficiently is very rarely taught at school - even though it came make a huge difference in engineering productivity and quality.

First, make sure you're familiar with the different kind of testing strategies laid out in Testing Strategies in a Microservices Architecture (Martin Fowler).

Then, read some of those articles:

  • Mock yourself, not your tests: great articles about the danger of mocking, and better unit testing strategies.
  • Building Good Tests, Chris NeJame
    • 1 assert per test function/method and nothing else
    • Use standard assert statements, instead of the unittest.TestCase assert methods
    • Test behavior, not implementation
    • Only verify state-changing method calls
    • Test the result, not the process
    • Every test should be able to be run in parallel with any other test
    • A test should never be flaky
    • Try to avoid mocking things whenever possible.
    • Test coverage is not a metric for what was tested; it’s a metric for what code your tests managed to hit
    • The code should be easy to test * Make your test code succinct and idiomatic
  • pytest is a test framework. It's very elegant and allows to quickly write very maintainable tests.
  • My Python testing style guide
    • Assert results and outcome, not the steps needed to get there
    • Use real objects for collaborators whenever possible
    • A mock must always have a spec
    • Consider using a stub or fake
    • Consider using a spy
    • Don't give mock/stubs/fakes special names
    • Use factory helpers to create complex collaborators
    • Use fixtures sparingly

Tools built with Python

  • pz: easily handle day to day CLI operation via Python instead of regular Bash programs.

Types

Unicode

Reference and other lists

Staying up to date

There are two main newsletters for Python, which mostly cover the same things:

You can also checkout the Python subreddit.

Non-Python professional coding education

Read this up on my professional programming doc.

If you want to get in touch, checkout my website.

My other lists

About

Reading list for ramping up with professional Python

License:MIT License

Languages

Language:Python 100.0%