Objects and Methods

Why Abstraction Matters

When you use an object or library, you usually want its useful result, not an explanation of every internal step that produces that result. Abstraction makes this possible by hiding complexity so you can focus on what matters to you and ignore the rest. In programming, this means you can work with an object's methods without understanding all of the internal logic behind those methods.

Following a Method Request

A method is part of the interface through which you interact with an object. You call the method, provide the information it accepts, and use the result it returns. The internal work remains hidden. For example, when using BeautifulSoup, you can call find() with a tag name or CSS selector. You do not need to handle the tokenizer, tree builder, or search algorithm that operate behind that call.

Interface and Implementation

The interface is what you see and interact with: the methods you call, the parameters those methods accept, and the results they return. The implementation is everything hidden behind that interface, including the algorithms, data structures, and internal logic that make the methods work. The key to abstraction is keeping these two parts separate.

Hiding Internal Work

The important change is not that the internal work disappears. Instead, the user interacts with one clear operation rather than directly managing every internal step. This lets the user concentrate on the specific problem of finding information in the HTML.

Two Sides of Abstraction

Abstraction helps both sides of an object’s relationship. Users can use objects and libraries without understanding their internal details. Developers can build objects without knowing all the ways those objects will eventually be used. Developers need to design a clear, useful interface and make sure the implementation behind it works correctly.

Layered Systems

Real software systems are often built in layers. Your code can use high-level libraries. Those libraries can use lower-level libraries, which can use operating system functions. The operating system can use hardware drivers. Each layer provides an interface to the layer above it and hides the complexity of the layer below it.

When scraping a website, you can focus on the scraping task rather than TCP/IP packets or network hardware. BeautifulSoup can focus on parsing HTML rather than HTTP headers or socket connections. urllib can handle HTTP without requiring its users to think about TCP. The layers divide a complex system into manageable responsibilities.

• Your code uses high-level libraries.
• High-level libraries use lower-level libraries.
• Lower-level libraries use operating system functions.
• The operating system uses hardware drivers.
• Each layer exposes an interface and hides lower-level complexity.

Mistakes About Interfaces

• Treating the interface and implementation as the same thing.

  The interface is the part you interact with. The implementation is the hidden logic that makes the interface work.

  Fix: Identify the methods, accepted parameters, and returned results as the interface. Treat the internal algorithms, data structures, and logic as implementation details.

• Thinking abstraction means there is no internal complexity.

  The tokenizer, tree builder, and search algorithm still perform internal work; abstraction hides that work from the user.

  Fix: Remember that abstraction hides complexity rather than removing it.

• Believing a library user must understand the library's entire implementation.

  Abstraction allows users to focus on calling methods and using the results for their specific problem.

  Fix: Learn the interface you need and rely on the library's implementation behind that interface.

• Designing an object around every possible future use.

  Developers benefit from abstraction because they can build the object without knowing all the ways it will be used.

  Fix: Design a clear, useful interface and make sure its implementation works correctly.

Check Your Understanding

1. Objects expose methods as part of an interface. Those methods let users request behavior and use results without managing the hidden implementation. Abstraction separates what an object does from how it does it. Users benefit by focusing on their own problems, while developers benefit by building objects without anticipating every use. Layered systems extend the same idea across libraries, operating system functions, and hardware drivers.