One Hour After Training: Python Escape Sequences and Induction

After the afternoon session of our university's military training, I spent about an hour in the library. I kept the scope small: isinstance() and escape sequences such as \n and \t in Heima Programmer's Python course, followed by the section on induction in Understanding Analysis.

I had encountered these ideas before. This time, I wanted to look more closely at what each piece of notation—and each step in an argument—actually does.

Python: being precise about what the code does

isinstance(object, classinfo) checks whether an object is an instance of a given type, including its subclasses, and returns True or False. A tuple of types can be supplied to check for any one of them.

score = 92

print(isinstance(score, int))           # True
print(isinstance(score, (int, float)))  # True

Previously, my understanding of types was mostly attached to names such as int, float, and str. isinstance() makes a type check something the program can perform. That gives me a more concrete way to think about the conditions I might use when handling data.

There is also a small terminology correction worth making. \n and \t are not both “newline commands.” They are escape sequences within strings: \n represents a newline, while \t represents a horizontal tab.

message = "First line\n\tSecond line"
print(message)

Here, Second line starts on a new line and moves to the next tab stop. The visible spacing depends on the output environment. In these sequences, the backslash tells Python to interpret the following character specially.

The examples are simple, but I want to distinguish the string as written in the source from the text that appears when it is printed. Otherwise, a remembered pattern can become confusing as soon as paths, quotation marks, or formatting enter the picture.

Revisiting the course has made one weakness in my earlier studying more concrete: typing along with a lesson verifies that I followed the instructions, not that I can explain or adapt the code. I still need to change the types and string contents myself, predict the results, and check those predictions.

Induction: a familiar method, read more carefully

Understanding Analysis introduces induction through a property of the natural numbers. If a subset of the natural numbers contains 1, and containing n always implies that it also contains n + 1, then it contains every natural number.

In a proof, I need to keep three parts distinct:

• Base case: verify the statement at the starting value.
• Inductive hypothesis: fix an arbitrary natural number n and assume the statement holds there.
• Inductive step: use that assumption to prove the statement for n + 1.

The book illustrates this with the recursively defined sequence

x₁ = 1, with xₙ₊₁ = (1/2)xₙ + 1.

To show that the sequence is nondecreasing, begin with x₂ = 3/2, so x₁ ≤ x₂.

Now take an arbitrary natural number n and assume xₙ ≤ xₙ₊₁. Multiplying both sides by 1/2 and adding 1 gives

xₙ₊₁ = (1/2)xₙ + 1 ≤ (1/2)xₙ₊₁ + 1 = xₙ₊₂.

Thus the comparison between two consecutive terms carries over to the next pair. Together with the base case, this proves the inequality for every natural number n.

I studied induction in high school, so the calculation was familiar. Reading it in English shifted my attention toward the role of each statement. The inductive hypothesis does not grant the conclusion for every n in advance. It gives a particular assumption from which I must establish the next case, with n arbitrary throughout.

I can follow that structure in this example. Whether I can construct it unaided for a new problem is a question for the exercises.

What to check next

The hour did not take me far ahead in either course. It did help me state a few elementary ideas more accurately: newline and tab are different escape sequences; a type check is an executable condition; and induction depends on both an initial case and a valid step from one case to the next.

For the next review, I want to write a short program using type checks and escape sequences without copying the lesson. Then I will close the textbook and reconstruct the monotonicity proof, making the base case, hypothesis, and inductive step explicit. Those two small tests should tell me more than the feeling that the material looks familiar.