Python Workout, Second Edition 200 ten-minute exercises (Reuven M. Lerner)（Z-Library）

【One-Line Pitch】 A hands-on Python drill book that builds real fluency through 50 short, carefully sequenced exercises with detailed solutions. Best for readers who already know basic Python syntax and want to convert shaky knowledge into confident, everyday coding skill. 【Book Arc】 - **Opening (~0%–10%)**: Sets the philosophy—mastery comes from deliberate practice, not passive reading—and explains the book's structure: solve each exercise yourself, then compare against a worked solution, Python Tutor visualizations, and pytest tests. It also argues why leaning on AI before you can code undermines real learning. - **Early (~10%–35%)**: Builds fundamentals through numeric and string exercises. You reimplement built-ins (like a custom `mysum`), explore parameter types and the splat operator, handle floating-point formatting with f-strings, and confront Python's mutable/immutable distinction—especially why strings can't be changed in place. - **Middle (~35%–55%)**: Moves into collections—lists and tuples—covering when to use each, slicing behavior, out-of-bounds rules, and the practical consequences of mutability. Exercises push you to translate between data structures rather than just manipulate them. - **Late (~55%–85%)**: Extends into dictionaries, sets, file reading/writing, and functional-style comprehensions, then into modules, packages, and building your own iterable objects. (Excerpts do not cover these chapters in detail.) - **Ending (~85%–100%)**: Consolidates the full toolkit through the final exercises, reinforcing patterns you'll reuse daily and the troubleshooting instincts that come from having solved problems yourself. (Excerpts do not cover the closing chapters.) 【Key Takeaways】 - **Practice beats passive reading** (Opening): The book's core premise is that you only internalize Python by typing solutions, making mistakes, and reflecting—not by reading someone else's code. - **AI can create the illusion of learning** (Early): The author warns that chatbots are useful brainstorming partners for experienced coders but can impede beginners by short-circuiting the struggle that builds real skill. - **Parameter flexibility is a Python superpower** (Early): Exercises like `mysum` teach that Python doesn't overload functions by signature; instead you use `*args`, default values, and keyword parameters to handle varying inputs. - **Immutability has real consequences** (Early–Middle): Strings, tuples, and numbers can't be changed in place, which affects dict keys, thread safety, and why methods on immutable types return new objects. - **Lists and tuples serve different purposes** (Middle): Lists are for sequences of same-type items you'll modify; tuples are for fixed records of different-type fields—choosing wrong leads to awkward code. - **Slicing is forgiving, indexing is not** (Middle): Out-of-range single indexes raise `IndexError`, but slices silently clamp to boundaries—a distinction that trips up beginners. - **Reimplementing built-ins deepens understanding** (Early–Middle): Writing your own `sum` or Pig Latin translator forces you to think about iteration, data structures, and edge cases rather than calling a library. - **Comprehensions and iterables are everyday tools** (Late): The book treats functional patterns and custom iterable objects as core fluency, not advanced trivia. (Excerpts do not cover these chapters in detail.) 【Reading Tips】 - **Solve before you look**: Attempt each exercise for at least ten minutes before reading the solution. The struggle is the point—skipping it wastes the book's main value. - **Deep-read the "Working it out" sections**: These explain design decisions and Python semantics (like why assignment isn't an expression), which matter more than the final code. - **Skim what you already know**: If numeric types and strings are solid, move faster through the early chapters and spend your time on collections, files, and iterables. - **Use the companion resources**: Python Tutor links, downloadable code, and pytest tests let you verify your solution and see execution step by step—use them to debug your mental model, not just your syntax. - **Keep a mistake log**: Note which exercises exposed gaps (e.g., mutability, slicing bounds) and revisit those concepts before moving on. 【Coverage Limits】 The excerpts cover the book's opening philosophy, early numeric/string material, and part of the collections chapters; later chapters on dictionaries, sets, files, comprehensions, modules, and iterables are only named, not detailed. This guide therefore describes the book's approach and early content more concretely than its later exercises.