finished debugging

Author: thomasWeise

text/main/classes/dunder/dunder.tex

@@ -543,7 +543,14 @@
 The Boolean variable \pythonil{negative} is set to \pythonil{True} if \pythonil{a < 0} and to \pythonil{negative} otherwise.
 We then make sure that \pythonil{a} is positive by computing~\pythonil{abs(a)}.
 Then we also copy the \pgls{denominator} into a variable~\pythonil{b}.
-
+We will not change the local variable~\pythonil{b} in our function, so we mark it with the \pgls{typeHint}~\pythonilIdx{Final}.%
+%
+\bestPractice{varFinal}{%
+Every time you declare a variable that you do not intend to change, mark it with the \pgls{typeHint}~\pythonilIdx{Final}. %
+On one hand, this conveys the intention \inQuotes{this does not change} to anybody who reads the code. %
+On the other hand, if you do accidentally change it later, tools like \mypy\ can notify you about this error in your code.%
+}%
+%
 We now want to fill a list~\pythonil{digits} with the digits representing the fraction in a \pythonil{while}~loop.
 Let us assume that our fraction is~$-\frac{179}{16}$.
 Then \pythonil{negative == True}, \pythonil{a = 179}, and \pythonil{b = 16}.
@@ -638,6 +645,9 @@
 Interestingly, they fail!
 The output tells us that \pythonil{Fraction(91995, 100000).decimal_str(3)} does not yield the expected~\pythonil{"0.92"}.
 Instead, we get \pythonil{"0.9110"}.
+Where does the trailing zero come from?
+And why do we have two 1s?
+Even if we did not round correctly, at least we should get something like~0.919, but certainly not~0.911?
 
 \begin{figure}%
 \centering%
@@ -687,8 +697,13 @@
 What we did not see in that output is that actually \emph{two} \pglspl{doctest} failed.
 A left-click on the second failed test in~\cref{fig:dunder:doctests3} tells us that \pythonil{Fraction(99995, 100000).decimal_str(4)} did not yield the expected~\pythonil{"1"}.
 Instead, it produced~\pythonil{"0.99910"}.
+Why is there a \pythonil{"0"} at the end of our number?
+Where did it come from?
+Zeros at the end should not be possible with our code.
+Also, there are four~9s in our number, not three.
+What went wrong here?
 
-While you might have guessed the problem when reading our code for \pythonil{decimal_str}, let us here assume that we are clueless why these tests fail.
+We are clueless why these tests fail.
 The question arises:
 What can we do?
 
@@ -754,6 +769,7 @@
 \caption{Using the \debugger\ in \pycharm.}%
 \label{fig:dunder:debugA}%
 \end{figure}%
+\afterpage{\clearpage}%
 %
 In \pycharm, we can apply the \debugger\ to a complete program, but also to \pglspl{doctest}.
 This is what we will do in \cref{fig:dunder:debugA}.
@@ -832,6 +848,7 @@
 \caption{Using the \debugger\ in \pycharm.}%
 \label{fig:dunder:debugB}%
 \end{figure}%
+\afterpage{\clearpage}%
 
 This test case is already successful, so we are not interested in it.
 Among the symbols in \menu{Debug} register, we click \pycharmDebuggerResume, which will let the program continue its execution~(\cref{fig:dunder:debug07}).
@@ -845,9 +862,8 @@
 When the debugger arrives at the fifth test case, \pythonil{Fraction(1235, 1000)}, we find that this fraction has been normalized correctly to~$\frac{247}{200}$.
 Nonetheless, we can skip this test case via \keys{F9}, too, because we know that it will succeed~(\cref{fig:dunder:debug11}).
 This takes us to the last successful \pgls{doctest} case, \pythonil{Fraction(99995, 100000)}, which corresponds to~$\frac{19999}{20000}$ in \cref{fig:dunder:debug12}.
-After skipping it by pressing~\pycharmDebuggerResume, we will finally arrive at the cases that did fail and which we hence want to investigate step-by-step.%
-\clearpage%
-%
+After skipping it by pressing~\pycharmDebuggerResume, we will finally arrive at the cases that did fail and which we hence want to investigate step-by-step.
+
 \begin{figure}%
 \ContinuedFloat%
 \centering%
@@ -902,6 +918,7 @@
 \caption{Using the \debugger\ in \pycharm.}%
 \label{fig:dunder:debugC}%
 \end{figure}%
+\afterpage{\clearpage}%
 %
 \begin{sloppypar}%
 \Cref{fig:dunder:debug13} shows that we now arrived at the beginning of the failing \pgls{doctest} case \pythonil{Fraction(91995, 100000).decimal_str(3)}.
@@ -960,27 +977,31 @@
 \strut\hfill\strut%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{digits} now contains the result of \pythonil{a // b}, i.e., is~\pythonil{[0]}. %
+We press~\keys{F8}.%
 \label{fig:dunder:debug22}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug22}}}%
 %
 \\[10pt]%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{a} now is \pythonil{183990}. %
+We press~\pycharmDebuggerStepOver\ to continue.%
 \label{fig:dunder:debug23}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug23}}}%
 %
 \strut\hfill\strut%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+We hit the \keys{F8} key to continue. %
+The loop condition is still met, so the first line of the loop body is marked again.%
 \label{fig:dunder:debug24}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug24}}}%
 %
 \caption{Using the \debugger\ in \pycharm.}%
 \label{fig:dunder:debugD}%
-\end{figure}
+\end{figure}%
+\afterpage{\clearpage}%
 
 This executes \pythonil{b = self.b}.
 Thus, the new local variable \pythonil{b} with value \pythonil{20000} is created in~\cref{fig:dunder:debug19}.
@@ -995,49 +1016,61 @@
 In \cref{fig:dunder:debug21}, we find that now the first line of the loop's body is marked.
 This means that \pythonil{a != 0} and \pythonil{len(digits) <= max_frac} are both~\pythonil{True}.
 And they should be, since \pythonil{a} is \pythonil{18399}, \pythonil{len(digits)} if~0, and \pythonil{max_frac} is~3.
-We press~\pycharmDebuggerStepOver.
+We press the \pycharmDebuggerStepOver~button to execute the first line of the loop body.
+
+\pythonil{digits.append(a // b)} will append the value \pythonil{18399 // 20000} to the list~\pythonil{digits}.
+As this is the result of an integer division where the \pgls{denominator} is larger than the \pgls{numerator}, \pythonil{digits} is now~\pythonil{[0]}~(\cref{fig:dunder:debug22}).
+We press \keys{F8} to continue.
+
+Now, \pythonil{a = 10 * (a \% b)} is executed.
+Since \pythonil{18399 \% 20000} is still \pythonil{18399}, \pythonil{a} becomes \pythonil{183990} in \cref{fig:dunder:debug23}.
+The head of the loop is now marked again.
+We press the \pycharmDebuggerStepOver~button to let execute it.
+
+In \cref{fig:dunder:debug24}, we again hit \keys{F8}.
+The loop condition is still met, so the first line in the loop body is marked again.
 
 \begin{figure}%
 \ContinuedFloat%
 \centering%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{9} gets appended to \pythonil{digits}.%
 \label{fig:dunder:debug25}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug25}}}%
 %
 \strut\hfill\strut%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{a} gets updated to \pythonil{39900}.%%
 \label{fig:dunder:debug26}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug26}}}%
 %
 \\[10pt]%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+The loop condition is still met.%
 \label{fig:dunder:debug27}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug27}}}%
 %
 \strut\hfill\strut%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{1} gets appended to \pythonil{digits}.%
 \label{fig:dunder:debug28}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug28}}}%
 %
 \\[10pt]%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{a} gets updated to \pythonil{199000}.%
 \label{fig:dunder:debug29}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug29}}}%
 %
 \strut\hfill\strut%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+The loop condition is still met.%
 \label{fig:dunder:debug30}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug30}}}%
 %
@@ -1046,51 +1079,110 @@
 \label{fig:dunder:debugE}%
 \end{figure}%
 %
-%
 \begin{figure}%
 \ContinuedFloat%
 \centering%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{9} gets appended to \pythonil{digits}.%
 \label{fig:dunder:debug31}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug31}}}%
 %
 \strut\hfill\strut%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+\pythonil{a} gets updated to \pythonil{190000}.%
 \label{fig:dunder:debug32}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug32}}}%
 %
 \\[10pt]%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+Since the loop condition evaluates to \pythonil{False}, the cursor is now at the next line after the loop body. %
+This line checks whether we should round up the next digit. %
+We hit \keys{F8}.%
 \label{fig:dunder:debug33}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug33}}}%
 %
 \strut\hfill\strut%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+The condition of the \pythonil{if} is met, we can now execute its body. %
+We press the \pycharmDebuggerStepOver~button.%
 \label{fig:dunder:debug34}%
 ]{\tightbox{\includegraphics[width=0.48\linewidth]{\currentDir/debug34}}}%
 %
 \\[10pt]%
 %
 \subfloat[][%
-Using the \debugger\ in \pycharm.%
+Our code for rounding up actually turned the last digit into a~\pythonil{10}! %
+Because we did not consider that rounding up could cause the next~9 to become a 10, which should be represented as a~0 and lead to the next digit to be rounded up as well.%
 \label{fig:dunder:debug35}%
 ]{\tightbox{\includegraphics[width=0.8\linewidth]{\currentDir/debug35}}}%
 %
 \caption{Using the \debugger\ in \pycharm.}%
 \label{fig:dunder:debugF}%
 \end{figure}%
-%
+\afterpage{\clearpage}%
+
+In \cref{fig:dunder:debug25,fig:dunder:debug26,fig:dunder:debug27,fig:dunder:debug29,fig:dunder:debug30,fig:dunder:debug31,fig:dunder:debug32} we work our way through the loop in the same way, by pressing \keys{F8} repeatedly.
+First, \pythonil{9} gets appended to \pythonil{digits}, then \pythonil{a} gets updated to \pythonil{39900}.
+In the following iteration, \pythonil{1} gets appended to \pythonil{digits}, then \pythonil{a} gets updated to \pythonil{199000}.
+Then, \pythonil{9} gets appended to \pythonil{digits} and \pythonil{a} gets updated to \pythonil{190000}.
+
+At this stage, \pythonil{digits} has become~\pythonil{[0, 9, 1, 9]}.
+Since \pythonil{max_frac} is \pythonil{3}, \pythonil{len(digits) <= max_frac} is no longer~\pythonil{True}.
+In \cref{fig:dunder:debug32}, we have arrived back at the head of the loop.
+When we hit \keys{F8}, the loop condition is evaluated again, but this time it evaluates to~\pythonil{False}.
+The loop terminates and the cursor is placed on the next line of code after the loop.
+
+If we look at what was computed so far, we find that everything is exactly as it should be.
+We want to translate the fraction~$\frac{91995}{100000}$ to a decimal string with three fractional digits.
+So far, we got the digits~0, 9, 1, and~9.
+
+The next line of code, \pythonil{if (a // b) >= 5}, is supposed to check whether we should round up the last digit.
+Since \pythonil{a} is \pythonil{190000} and \pythonil{b} is still \pythonil{20000}, \pythonil{a // b} is~\pythonil{9}.
+So the condition should be met.
+In \cref{fig:dunder:debug32}, we press the \pycharmDebuggerStepOver~button to find it out.
+
+A look at \cref{fig:dunder:debug35} reveals the bug in our code:
+In order to round up, we incremented the last number in our list~\pythonil{digits}.
+\pythonil{digits} was~\pythonil{[0, 9, 1, 9]}.
+So it is~\pythonil{[0, 9, 1, 10]}.
+
+The strange trailing zeros in our output were not separate digits.
+They were the zeros of a ten.
+We did not consider that, when rounding up, we do not just have simple cases like~1.25 which we can round to~1.3 by only incrementing one digit.
+We can have cases like~0.9999, which rounds up to~1, even if we want three fractional digits of precision.
+We can stop the debugging here and go back to our code.
+
 \gitPython{\programmingWithPythonCodeRepo}{09_dunder/fraction.py}{--args format --labels part_6}{dunder:fraction:part_6}{%
 The repaired Part~6 of the \pythonil{Fraction} class: A correct \pythonil{decimal_str} method.}%
-%
+
+In \cref{dunder:fraction:part_6}, we revisit the \pythonil{decimal_str} method of our class~\pythonil{Fraction}.
+Our rounding-up code becomes more complex:
+First, we need to loop over all fractional digits, from the end of the list \pythonil{digits} forward:
+\pythonil{for i in range(len(digits) - 1, 0, -1)} does this.
+If \pythonil{len(digits) == 5}, then \pythonil{range(len(digits) - 1, 0, -1)} iterates over the numbers 4, 3, 2, and~1.
+We increment the digit at index~\pythonil{i} by~1.
+If it does not become~10, then we can stop the loop via~\pythonilIdx{break}.
+If it did become~10, then we set it to zero and continue the loop.
+This will increment the next digit, and so on.
+If we arrive at index~1 and still need to continue, the regular loop execution ends anyway.
+
+Then, the \pythonil{else} statement is hit.
+Recall from \cref{sec:loopElse} that the \pythonil{else}\pythonIdx{for!else} statement at the bottom of a loop is \emph{only} executed if the loop finished regularly, i.e., if no \pythonil{break} statement was executed.
+Therefore, if and only if the digit at index~1 also became~10 and was then set to~0, we increment the digit at index~0.
+This digit represents the integer part of our fraction.
+Here, it is totally OK to round a~9 to a~10.
+For example, 9.999 can be rounded to 10, and 1239.9 can be rounded to 1240.
+
+This new code for rounding numbers may introduce zeros at the end of our string.
+We just gobble them up with an additional \pythonil{while} loop directly after the rounding.
+And with this, we are done.
+We have working code converting fractional numbers to decimal strings.
+All the \pglspl{doctest} now pass.
+
 \gitPython{\programmingWithPythonCodeRepo}{09_dunder/fraction_sqrt.py}{--args format}{dunder:fraction_sqrt}{%
 Using the \pythonil{Fraction} class to compute square roots.}%
 %

text/main/controlFlow/loops/loops.tex

@@ -434,6 +434,7 @@
 %
 %
 \hsection{The \texttt{else} Statement at the Bottom of Loops}%
+\label{sec:loopElse}%
 %
 Now, you have learned before that we can leave a loop body immediately by calling the~\pythonilIdx{break} statement.
 Let's say that we want to perform a certain action \emph{after} the loop if the loop has completed normally, i.e., if \pythonilIdx{break} was not invoked.