Commit 45c7ec1

A major use of inheritance is in writing code that’s meant to be extended or customized in various ways—especially in libraries or frameworks.

To illustrate, start by adding the following function to your `stock.py` program:

IBM 100 70.44

Suppose that you wanted to modify the `print_portfolio()` function to

support a variety of different output formats such as plain-text,

When you run this new code, your program will immediately crash with a `NotImplementedError` exception.

That’s not too exciting, but continue to the next part.

The `TableFormatter` class you defined in part (a) is meant to be extended via inheritance.

In fact, that’s the whole idea. To illustrate, define a class `TextTableFormatter` like this:

Test your code by modifying the main program to create a `HTMLTableFormatter` object instead of a `CSVTableFormatter` object.

A major feature of object-oriented programming is that you can plug an

object into a program and it will work without having to change any of

pretty far in terms of using most library modules and knowing

what inheritance is good for (extensibility).

All Python objects have two string representations. The first

representation is created by string conversion via `str()` (which is

In Exercise 4.2 you worked with a function `print_portfolio()` that made a table for a stock portfolio.

That function was hard-coded to only work with stock data—-how limiting! You can do so much more if you use functions such as `getattr()`.

Modify the `print_table()` function in part (B) so that it also

accepts a list of format specifiers for formatting the contents of

It is often good practice for libraries to define their own exceptions.

FormatError: Unknown table format xls

In this exercise, we will use that class.

At the interactive shell, inspect the underlying dictionaries of the two instances you created:

Try setting a new attribute on one of the above instances:

manipulation of the dictionary is uncommon—you should always write

your code to use the (.) syntax.*

The definitions that make up a class definition are shared by all instances of that class.

Notice, that all instances have a link back to their associated class:

A subtle feature of Python is that invoking a method actually involves

two steps and something known as a bound method.

Make a new class that inherits from `Stock`.

Properties are a useful way to add "computed attributes" to an object.

In Exercise 4.1, you created an object `Stock`. Notice that on your

Modify the `shares` attribute so that the value is stored in a private

attribute and that a pair of property functions are used to ensure

Modify the `Stock` class so that it has a `__slots__` attribute.

Then, verify that new attributes can’t be added:

It should be noted that `__slots__` is most commonly used as an

optimization on classes that serve as data structures. Using slots

will make such programs use far-less memory and run a bit faster.

Create the following list:

Keep calling `next(f)` until you reach the end of the

file. Watch what happens.

On occasion, you might want to make one of your own objects support

iteration--especially if your object wraps around an existing

If making a container class, you often want to do more than just

iteration. Modify the `Portfolio` class so that it has some other

indexing, containment, and other kinds of operators is an important

part of this.

If you ever find yourself wanting to customize iteration, you should

always think generator functions. They're easy to write---make

custom processing in a function and use it to feed a for-loop.

The next example looks at a more unusual case.

Generators can be an interesting way to monitor real-time data sources

such as log files or stock market feeds. In this part, we'll

see if more data has been added (`readline()` will either

return new data or an empty string).

If you look at the code in part (b), the first part of the code is producing

lines of data whereas the statements at the end of the `while` loop are consuming

print(f'{name:>10s} {price:>10.2f} {change:>10.2f}')

Modify the `follow.py` program so that it watches the stream of stock

data and prints a ticker showing information for only those stocks

example, you could use it to watch server logs, debugging logs, and other similar data sources.

That's kind of cool.

For this exercise the `stocksim.py` program should still be running in the background.

You’re going to use the `follow()` function you wrote in the previous exercise.

Let's see the pipelining idea in action. Write the following

function:

It might take awhile for output to appear, but eventually you

should see some lines containing data for IBM.

Take the pipelining idea a few steps further by performing

more actions.

`follow()` function has been piped into the `csv.reader()` function and we're

now getting a sequence of split rows.

Let's extend the whole idea into a larger pipeline. In a separate file `ticker.py`,

start by creating a function that reads a CSV file as you did above:

Write a function that filters data. For example:

print(row)

In the `ticker.py` program, write a function `ticker(portfile, logfile, fmt)`

that creates a real-time stock ticker from a given portfolio, logfile,

series of pipeline stages into a single function call (for example,

the `parse_stock_data()` function).

In the previous exercises, you wrote some code that followed lines being written to a log file and parsed them into a sequence of rows.

This exercise continues to build upon that. Make sure the `Data/stocksim.py` is still running.

Generator expressions are a generator version of a list comprehension.

For example:

>>>

Generator expressions are sometimes placed into function arguments.

It looks a little weird at first, but try this experiment:

involving list comprehensions. Try replacing these with

generator expressions.

Generators expressions are often a useful replacement for

small generator functions. For example, instead of writing a

as appropriate.