some improvements

Author: thomasWeise

README.md

@@ -33,6 +33,7 @@ Die Slides zum Kurs in deutscher Sprache können unter <https://thomasweise.gith
 8. [Der Datentyp `float`](https://thomasweise.github.io/programmingWithPythonSlidesDE/08_float.pdf)
 9. [Zwischenspiel: Python Dokumentation und Informationsquellen](https://thomasweise.github.io/programmingWithPythonSlidesDE/09_dokumentation.pdf)
 10. [Der Datentyp `bool`](https://thomasweise.github.io/programmingWithPythonSlidesDE/10_bool.pdf)
+11. [Der Datentyp `str`](https://thomasweise.github.io/programmingWithPythonSlidesDE/11_str.pdf)
 
 ### 2.3. The Slides in English
 The slides for the course are available at <https://thomasweise.github.io/programmingWithPythonSlides> and also listed below.

bookbase

@@ -1,7 +1,7 @@
 \hsection{Text Strings}%
 \label{sec:str}%
 %
-The fourth important datatype in \python\ are text strings.
+The fourth and last important basic datatype in \python\ are text strings.
 Text strings are sequences of characters of an arbitrary length.
 In \python, they are represented by the datatype \pythonilIdx{str}.
 Indeed, we have already used it before, even in our very first example program back that simply printed \pythonil{"Hello World"} in \cref{lst:very_first_program} in \cref{sec:ourFirstProgram}.
@@ -16,10 +16,10 @@
 As \cref{exec:str_indexing} shows, there are two basic ways to specify a text string literal\pythonIdx{str!literal}:
 Either enclosed by double quotes, e.g., \pythonil{"Hello World!"}\pythonIdx{\textquotedbl\idxdots\textquotedbl} or enclosed by single quotes, e.g., \pythonil{'Hello World!'}\pythonIdx{\textquotesingle\idxdots\textquotesingle}.
 The quotation marks are only used to delimit the strings, i.e., to tell \python\ where the string begins or ends.
-They are not themselves part of the string.
-
-\bestPractice{strDoubleQuote}{When defining a string literal, the double-quotation mark variant~(\pythonil{"..."}\pythonIdx{\textquotedbl\idxdots\textquotedbl}) may be preferred over the single-quotation mark variant~(\pythonil{'...'}\pythonIdx{\textquotesingle}); see also~\cref{bp:longstrDoubleQuote}.}
-
+They are not themselves part of the string.%
+%
+\bestPractice{strDoubleQuote}{When defining a string literal, the double-quotation mark variant~(\pythonil{"..."}\pythonIdx{\textquotedbl\idxdots\textquotedbl}) may be preferred over the single-quotation mark variant~(\pythonil{'...'}\pythonIdx{\textquotesingle}).~(The \citetitle{PEP8}~\cite{PEP8} does not give a recommendation, but maybe for consistency with the~\citetitle{PEP257}~\cite{PEP257}, see also~\cref{bp:longstrDoubleQuote}.)}%
+%
 One basic operation is string concatenation\pythonIdx{str!concatenation}\pythonIdx{str!+}\pythonIdx{+}:
 \pythonil{"Hello" + ' ' + "World"}\pythonIdx{\textquotedbl\idxdots\textquotedbl}\pythonIdx{\textquotesingle\idxdots\textquotesingle} concatenates the three strings \pythonil{"Hello"}, \pythonil{" "}, and \pythonil{"World"}.
 The result is \pythonil{"Hello World"}\pythonIdx{\textquotedbl\idxdots\textquotedbl}.
@@ -68,6 +68,8 @@
 Finally, we can also omit the start index, in which case everything until right before the end index is returned.
 Therefore, \pythonil{"Hello"[:-2]} will return everything from the beginning of the string until right before the second-to-last character.
 This gives us \pythonil{"Hel"}.
+The slice~\pythonil{[1:8:2]} returns the substring starting at index~1 and ending before index~8, containing every second character.
+Applied to~\pythonil{"Hello World!"} it therefore yields~\pythonil{"el o"}.
 We will discussing slicing again later when discussing lists in~\cref{sec:lists}.
 
 \gitEvalPython{str_basic_ops}{}{simple_datatypes/str_basic_ops.py}%
@@ -87,8 +89,11 @@
 It returns \pythonil{6}, because the \inQuotes{W} of \inQuotes{World} is the seventh character in this string and the indices are zero-based.
 Trying to find the \pythonil{"world"} in \pythonil{"Hello World!"} yields~\pythonil{-1}, however.
 \pythonil{-1} means that the string cannot be found.
+
 We learn that string operations are case-sensitive\pythonIdx{str!case-sensitive}:
-\pythonil{"World" != "world"} would be \pythonilIdx{True}.
+The uppercase character~\inQuotes{W} is different from the lowercase character~\pythonil{w}.
+Therefore, \pythonil{"World" != "world"} is~\pythonilIdx{True}.
+Therefore, \pythonil{"world"} cannot be found in \pythonil{"Hello World!"}.
 We also learn that we need to be careful not to use the result of \pythonilIdx{find} as index in a string directly before checking that it is \pythonil{>= 0}!
 As you have learned, \pythonil{-1} is a perfectly fine index into a string, even though it means that the string we tried to find was not found.
 
@@ -106,18 +111,22 @@
 If we want to search from the end of the string, we use \pythonilIdx{rfind}.
 \pythonil{"Hello World!".rfind("l")} gives us~\pythonil{9} directly.
 If we want to search for the~\inQuotes{l} before that one, we need to supply an inclusive starting and exclusive ending index of the range to be searched.
-\pythonil{"Hello World!".rfind("l", 0, 9)} searches for any~\inQuotes{l} from index~8 down to~0 and thus returns~\pythonil{3}.
+\pythonil{"Hello World!".rfind("l", 2, 9)} searches for any~\inQuotes{l} from index~8 down to~2 and thus returns~\pythonil{3}.
 \pythonil{"Hello World!".rfind("l", 0, 3)} gives us~\pythonil{2} and since there is no~\inQuotes{l} before that, \pythonil{"Hello World!".rfind("l", 0, 2)} yields~\pythonil{-1}.
 \end{sloppypar}%
 %
 \begin{sloppypar}%
 Another common operation is to replace substrings with something else.
 \pythonil{"Hello World!".replace("Hello", "Hi")}\pythonIdx{replace} replaces all occurrences of \inQuotes{"Hello"} in \inQuotes{Hello World} with \inQuotes{Hi}.
-The result is \pythonil{"Hi World!"} and \pythonil{"Hello Hello World!".replace("Hello", "Hi")} becomes \pythonil{"Hi Hi World!"}.
+The result is \pythonil{"Hi World!"} and \pythonil{"Hello World! Hello!".replace("Hello", "Hi")} becomes \pythonil{"Hi World! Hi!"}.
+It does not replace strings recursively, though.
+If you try to do \pythonil{"Hello World!".replace("Hello", "Hello! Hello!")}, then the \pythonil{"Hello"} is indeed replaced with \pythonil{"Hello! Hello!"}.
+This means that the new string now contains \pythonil{"Hello"} twice.
+These new occurrences are \emph{not} replaced, so the result remains as \pythonil{"Hello! Hello! World!"}.%
 \end{sloppypar}%
 %
 \begin{sloppypar}%
-Often, we want to remove all leading or trailing whitespace characters from a string.
+Often, we want to remove all leading or trailing whitespace characters~(spaces, newlines, tabs, \dots) from a string.
 The \pythonilIdx{strip} function does this for us:
 \pythonil{" Hello World! ".strip()} returns \pythonil{"Hello World!".strip()}, i.e., the same string, but with the leading and trailing space removed.
 If we only want to remove the spaces on the left-hand side, we use \pythonilIdx{lstrip} and if we only want to remove those on the right-hand side, we use \pythonilIdx{rstrip} instead.
@@ -134,6 +143,7 @@
 
 Of course, these were just a small selection of the many string operations available in \python.
 You can find more in the \href{https://docs.python.org/3/library/stdtypes.html\#textseq}{official documentation}~\cite{PSF:P3D:TPSL:TSTS}.%
+\FloatBarrier%
 \endhsection%
 %
 \hsection{The str Function and f-strings}%
@@ -273,6 +283,7 @@
 For example, you could write \pythonil{f"\{23\ *\ sin(2\ -\ 5)\ =\ :.2f\}"} and then the \pythonil{.2f} format would be applied to the result of the expression, i.e., you would get \pythonil{"23 * sin(2 - 5) = -3.25"} as the result of the extrapolation.
 
 You are now able to convert the results of your computations to nice text.%
+\FloatBarrier%
 \endhsection%
 %
 \hsection{Converting Strings to other Datatypes}%
@@ -298,6 +309,7 @@
 Finally, the function \pythonilIdx{bool}\pythonIdx{bool!function} converts the strings \pythonil{"True"} and \pythonil{"False"} to \pythonilIdx{True} and \pythonilIdx{False}, respectively.
 With this, you are also able to convert strings to data that you can use as input for your computations.%
 %
+\FloatBarrier%
 \endhsection%
 %
 %
@@ -359,6 +371,7 @@
 We already learned the sequences \inQuotes{\textbraceleft\textbraceleft}\pythonIdx{\textbraceleft\textbraceleft} and \inQuotes{\textbraceright\textbraceright}\pythonIdx{\textbraceright\textbraceright} that were designed for \pglspl{fstring} only.
 The backslash-based escape sequence we discussed in this section work for both \pglspl{fstring} and normal strings.%
 \pythonIdx{str!escaping}\pythonIdx{escaping}%
+\FloatBarrier%
 \endhsection%
 %
 \hsection{Multi-Line Strings}%
@@ -372,10 +385,10 @@
 Such string delimiters are used for multi-line strings.
 In such strings, you can insert linebreaks by hitting \keys{\enter} completely normally.
 You can use the escape sequences from the previous section as well.
-The main use case are \pglspl{docstring}, which we will discuss later, see, e.g., \cref{bp:module:docstrings}.
-
-\bestPractice{longstrDoubleQuote}{When defining a multi-line string literal, the double-quotation mark variant~(\pythonil{"""..."""})\pythonIdx{\textquotedbl\textquotedbl\textquotedbl\idxdots\textquotedbl\textquotedbl\textquotedbl} is usually preferred over the single-quotation mark variant~(\pythonil{'''...'''}\pythonIdx{\textquotesingle\textquotesingle\textquotesingle})~\cite{PEP257,PEP8}.}
-
+The main use case are \pglspl{docstring}, which we will discuss later, see, e.g., \cref{bp:module:docstrings}.%
+%
+\bestPractice{longstrDoubleQuote}{When defining a multi-line string literal, the double-quotation mark variant~(\pythonil{"""..."""})\pythonIdx{\textquotedbl\textquotedbl\textquotedbl\idxdots\textquotedbl\textquotedbl\textquotedbl} is preferred over the single-quotation mark variant~(\pythonil{'''...'''}\pythonIdx{\textquotesingle\textquotesingle\textquotesingle})~\cite{PEP257,PEP8}.}%
+%
 \cref{exec:str_multiline} shows what happens if we print such a multi-line string.
 We first create the string by writing the three lines \textil{This is a multi-line string.}, \textil{I can hit enter to begin a new line.}, and \textil{This linebreak is then part of the string.}.
 The first line begins with \pythonil{"""}\pythonIdx{\textquotedbl\textquotedbl\textquotedbl\idxdots\textquotedbl\textquotedbl\textquotedbl} and the last one ends with \pythonil{"""}\pythonIdx{\textquotedbl\textquotedbl\textquotedbl\idxdots\textquotedbl\textquotedbl\textquotedbl} as well.
@@ -384,6 +397,7 @@
 We can also have multi-line \pglspl{fstring}\pythonIdx{str!f}\pythonIdx{f-string!multi-line}.
 These then simply start with \pythonil{f"""}\pythonIdx{f\textquotedbl\textquotedbl\textquotedbl\idxdots\textquotedbl\textquotedbl\textquotedbl}.
 The example in \cref{exec:str_multiline} presents such a multi-line \pgls{fstring} with two expressions for \pgls{strinterpolation} which spans over three lines.%
+\FloatBarrier%
 \endhsection%
 %
 \hsection{Unicode and Character Representation}%
@@ -439,6 +453,7 @@
 Anyway, in \cref{exec:str_unicode}, we use the information obtained in \cref{fig:unicodeCharacterTableSubset} to print the Chinese text \inQuotes{你好。} standing for \inQuotes{Hello.} and pronounced as \inQuotes{N{\v{\i}} h{\v{a}}o.} as a unicode-escaped string.
 We found that the character for \inQuotes{你} has unicode number~4f60, \inQuotes{好} has~597d, and the big period~\inQuotes{。} has~3002.
 The string \pythonil{"\\u4f60\\u597d\\u3002"} then corresponds to the correct Chinese text~\inQuotes{你好。}.%
+\FloatBarrier%
 \endhsection%
 %
 \hsection{Summary}%

text/main/basics/simpleDataTypesAndOperations/str/str.tex

@@ -46,25 +46,35 @@
 The latter is what \python\ does in the examples mentioned initially:
 While it could simply ignore if we try to overwrite an element of a \pythonil{tuple}, it instead raises an~\pythonilIdx{TypeError}, for example.
 Personally, I am also a fan of this approach.
-
+And the \python\ documentation is, too:%
+%
+\cquotation{PEP20}{%
+Errors should never pass silently. %
+Unless explicitly silenced.%
+}%
+%
 If we would follow the \pgls{GIGO} paradigm, then faulty data will propagate.
 Maybe the output of our function is fed as input into another function, whose output is then piped into another function, and so on.
 An error could then will lead to some crash down the line.
-If functions that are written under the assumption that \pgls{GIGO} is OK are paired with such that perform input sanitization, errors could remain unnoticed.
+Then again, if functions that are written under the assumption that \pgls{GIGO} is OK are paired with such that perform input sanitization, errors could remain unnoticed.
 The erroneous results could then become part of some actual, real-life decisions and designs.
 And even if found out, it will be extremely hard to discover where things went wrong in the long chain of computations and function calls.
+It could even be that faulty results are stored in files and then cause other tools to crash later.
+And \emph{later} could mean something like a week later.
+And \emph{other tools} could mean \emph{programs run by someone else in another department}.
+Good luck finding the piece of code that caused the error then.
 
 Input sanitization could cover some error that happened earlier.
 This could even cause more errors, because it will allow other programmers to call our code with wrong values.
-Input sanitization encourages sloppy programming.
+Input sanitization also encourages sloppy programming.
 
 This leaves raising an \pythonilIdx{Exception}.
 But what does that actually mean?
 Raising an \pythonilIdx{Exception} means two things:%
 %
 \begin{enumerate}%
 %
-\item We store information about the error and information about the current execution state (current line of code and the function call hierarchy) in an object (the \pythonilIdx{Exception}).%
+\item We store information about the error and information about the current execution state~(the current line of code and the function call hierarchy) in an object~(the \pythonilIdx{Exception}).%
 %
 \item The control flow immediately leaves the currently executed block of instructions as well as all calling blocks or functions.
 It jumps up in the call hierarchy until reaching code that handles the raised exception.