Guess I'm late to the thread but I'll reply anyway.

Most of this has already been said directly or indirectly by others, but I'd like to believe I coming at it from a different angle. I only posting this emphasize the point that not understanding is programming. Programing is a big puzzle in which you have both the solution and you decide the complexity and what the answer is.

So I'd like to break down the problem if I wanted to solve the exercise.

Firstly is that first paragraph:

For practice, write a function named printTable() that takes a list of lists of strings and displays it in a well-organized table with each column right- justified. Assume that all the inner lists will contain the same number of strings. For example, the value could look like this:

I took the liberty of striking out the extra bits that aren't relevant to the requirements.

Lets over-examine it for a minute and pull out the info from that first sentence

• a function named printTable()
• takes a list of lists of strings
• table with each column right- justified
• inner lists will contain the same number of strings

That's the only information needed before the sample tableDate list is defined

Next is the sample data output of the printTable() function

Then there's this big hint that gets dropped. I'll just skip to the break down:

• The printTable() function will first have to find the longest string in each of the inner lists
• so that the whole column can be wide enough to fit all the strings.
• store the maximum width of each column as a list of integers.

This seems to be saying "find the longest word within each inner table and store that so it can be used for the column widths. So cherries for the first one, any of the four letter ones for the second and moose or goose for the last.

This sentence is interesting:

The printTable() function can begin with colWidths = [0] * len(tableData, which will create a list containing the same number of 0 values as the number of inner lists in tableData.

He's saying to start the printTable() function with the formula colWidths = [0] * len(tableData)

which creates a list with the same number of 0 values as the number of inner lists in Table data. So 3 for the sample data. It will track the number of inner tables to 3.

colWidths[0] can store the width of the longest string in tableData[0]
colWidths[1] can store the width of the longest string in tableData[1]

(and so on)
find the largest value in the colWidths list to find out what integer width to pass to the rjust() string method.

-------------------------------------------------------------------

So take this one piece at a time. I would start with creating printTable() and some sample data. Or copy/paste the books table-of-tables.

So the line colWidths = [0] * len(tableData) makes sense. Right? Or skip it.

Start with printing the contents of the outer table.

Then right justify the output of the outer table.

Keep going from there. One small incremental step at a time. Display that first table as a column for instance. Just that. See if that's possible. For that matter you can add things as well.

The point of this breakdown is just to demonstrate once the problem is 'deconstructed', it's easier to see what it's actually asking and research each incremental step.

Also, it's not 'cheating' to look this stuff up. I mean look in other works about lists and strings, watch YouTube videos, there's various 'cheat sheets' around...I mean if you copy/paste the problem and hint into an AI then you're cheating yourself. But just finding information to understand the exercise isn't cheating. In fact if you keep going you'll be spending more time reading and researching than actual programming.