Level 5 exam — Python · GUIDINEE.COM

Exam — fresh questions

12 original questions to validate Pro level & industrialization: clean code, asyncio, Docker, deployment & CI/CD.
Answer everything, then click Check: your score and explanations will appear.

5.1 · Recall

1. What does the PEP 8 convention define?

The allowed servers for hosting The official Python style (naming, spacing, indentation) Python licence prices Code execution speed

PEP 8 standardises style; black formats it, ruff/flake8 flags deviations.

5.1 · Application

2. Nabil's script piles up elif for each computation mode. First pro move?

Adding even more elif, it is simpler Rewriting everything into one giant file Replacing the cascade with a named strategy (dictionary of functions) Deleting all file comments

Strategy: adding a mode becomes adding an entry, without touching the existing code.

5.1 · Arbitration

3. Nabil wants SOLID and patterns on a one-page throwaway script. Call?

Keep the script simple: structure what grows and lasts Impose three abstraction layers anyway Apply every pattern to look pro Never write a function again

Judgement: with no design problem, the pattern is dead weight.

5.2 · Application

4. Nabil hesitates between asyncio and multiprocessing for heavy pure number-crunching. What to pick?

multiprocessing: the bottleneck is computing, not waiting Neither: delete the computation Both at once on every line asyncio, which speeds up all computation

Pure computation (CPU-bound) → multiprocessing; asyncio serves waiting (I/O-bound).

5.2 · Application

5. Nabil's collection awaits three sources one after another. What does he do?

Moving everything to multiprocessing computation Deleting two sources out of three Adding servers without measuring Converting the loop to coroutines launched with asyncio.gather

Gather: waits overlap instead of adding up.

5.2 · Application

6. Nabil's gather stays slow: he uses requests in his coroutines. Diagnosis?

Deleting every await in the code Putting async on pure computation requests blocks the loop: switch to an async client (httpx/aiohttp) Adding even more blocking coroutines

Blocking code paralyses async: async end to end or not at all.

5.3 · Recall

7. What does a Docker container hold?

Nothing at all, it is an empty folder The application WITH its whole environment, portable everywhere Code only with no environment Only decorative images

The container ships its environment: identical from PC to server.

5.3 · Application

8. Nabil's app works in Algiers but not on his colleague's machine (missing dependencies). What does he do?

Copying his .venv on a USB stick Reinstalling Python at random on each machine Dropping the project Writing a slim Dockerfile (requirements before code) + Compose

Dockerfile + build + run: same image, same behaviour everywhere.

5.3 · Arbitration

9. Nabil listens on localhost in the container: unreachable. Call?

Copying .venv into the image to force it Deleting the Dockerfile Keeping localhost, it will work out Listening on 0.0.0.0 + non-root USER + .dockerignore

In a container: mandatory 0.0.0.0, systematic non-root, lean context.

5.4 · Recall

10. What does a CI/CD pipeline (GitHub Actions) do?

It replaces logs and rollback It deletes the database on every push It tests on every push and deploys if all passes It writes the application code alone

CI (ruff + pytest on every push) then versioned delivery if green.

5.4 · Application

11. Nabil deploys: where do the API key and database password go?

Hardcoded in the source code In repo secrets / environment variables, never in plain text In a public code comment In plain text in YAML, it is convenient

Secrets out of YAML, out of code, out of the repo — prod is configured.

5.4 · Arbitration

12. Before exposing real data, what must Nabil do?

Get infra, access and backups validated by IT, offers checked when choosing Delete logs and /health to go faster Deploy fast without telling anyone Publish secrets to ease access

Sensitive data: IT validation, backups, checked offers, monitoring in place.

What's next?

Score ≥ 80%: move to Level 6 “In practice” — concrete cases, troubleshooting and the Python toolbox (NO exam).
Score 50-79%: reread the explanations above — each one re-explains the concept — then redo the failed 48h challenges.
Score < 50%: revisit cards 5.2 (async vs computing) and 5.3 (image vs container), your two vital moves, before continuing.