Lecture 2: Strings, Input/Output, and Branching

Main ideas / lessons

• Recap: Python objects, types, variables, and evaluation

  • Every value in Python is an object with a type that determines what you can do with it.
  • Variables bind a name to an object in memory.
  • Expressions evaluate to values; assignments bind results to names.
  • Key behavior: operations typically create new objects rather than modifying old ones (e.g., rebinding radius to a new computed value).
  • Even assignment statements like VAR = 5 * 4 involve expression evaluation on the right-hand side, producing a value and type (e.g., VAR becomes an integer type).

• New data type: Strings

  • A string is a sequence of characters (case-sensitive).
  • Strings are created using quotation marks.
  • Variables can bind strings similarly to numbers.

• Common string operations

  • Concatenation (a + b)
    • Produces a new string object by joining characters from left to right.
    • Strings do not automatically include spaces—spaces must be included explicitly.
  • Repetition (string * n and n * string)
    • Repeats the string sequence n times.
    • Must use an integer; string * non-integer causes a type error.
  • Type casting requirement
    • If user input or another value is an integer stored as a string, you may need int(...) or str(...) to make operations type-compatible.
  • Length (len(s))
    • Returns the number of characters in the string.
  • Indexing (single-character access)
    • Uses square brackets: s[index]
    • Indexing starts at 0 (first character).
    • Negative indexing supported: s[-1] is the last character.
    • Indexing outside valid range raises IndexError.
  • Slicing (substring extraction)
    • Uses square brackets with start:stop:step:
      • Start = where to begin
      • Stop = where to end (exclusive, not included)
      • Step = how much to skip (default step is 1 if omitted)
    • If step is omitted, it defaults to 1.
    • Slicing supports:
      • Forward slices (positive step): left to right
      • Reverse slices (negative step): right to left
    • Examples/concepts emphasized:
      • s[a:b] includes indices from a up to b-1
      • s[:] returns a copy of the whole string
      • s[::-1] reverses a string
      • Empty result is valid (produces an empty string "") when slice selects nothing.
  • Strings are immutable
    • You cannot change characters inside an existing string.
    • To “modify” a string, you must create a new string and rebind the variable.

• Input/Output (I/O)

  • Why the shell output isn’t “real output”
    • Typing expressions in the shell shows “peeks” at values.
    • In a script/file, Python prints nothing unless you explicitly request output.
  • Printing output
    • Use print(expression) to display the value.
    • Multiple items in one print call using commas:
      • print(x, y, z) prints items separated by a space automatically.
    • String concatenation with + requires compatible types:
      • Concatenating a string with an integer directly causes a TypeError.
      • Fix: cast non-strings, e.g. str(num).
  • User input
    • Use input(prompt) to ask for user text.
    • input(...) always returns a string.
    • To treat numeric input as a number, cast: int(input(...)) or float(...).
  • Interactive mini-program
    • Build a program that:
      • asks for a verb
      • prints I can <verb> better than you
      • prints <verb> five times on the next line
    • Spacing issues can occur; an improvement is to avoid trailing spaces in repeated output (challenge mentioned).

• Conditionals and branching (decision making)

  • Programs are not yet “decision-based” unless using branching logic.
  • Equality operators
    • = is assignment
    • == checks equivalence and returns a Boolean
  • Boolean expressions
    • Comparisons like 2 < 3 evaluate to True or False.
    • Common operators:
      • equality: ==
      • inequality: !=
      • less/greater: <, >
      • inclusive bounds: <=, >=
  • Boolean logic operators
    • and: true only if both sides are true
    • or: true if either side is true
    • not: flips True/False
  • Printing Boolean results
    • Example idea: compare a user’s guess to a secret number and print true/false.
  • Implementing if/elif/else
    • Syntax relies on indentation:
      • if condition: starts a block
      • indented lines are executed only if the condition is true
    • elif checks additional conditions when earlier ones fail.
    • else is executed only if none of the preceding conditions are true.
  • Debugging indentation mistakes
    • A common bug is printing at the wrong indentation level, causing output to appear even when a condition should be false.
    • Fix by nesting/indenting the print inside the correct if-block.
  • Nested conditionals
    • If statements can be nested inside other blocks to refine behavior.
  • Two independent if statements
    • Not all conditions are mutually exclusive; multiple if statements can both run if both conditions are true.
    • if/elif/else enforces “only one branch runs” (or none).
  • Program extension
    • Example task: compare a guess to a secret and print:
      • “too high”
      • “too low”
      • “equal”

• (Applied example) Newton’s method fragment

  • Shows using arithmetic and casting with input:
    • ask for cube root target X
    • ask for initial guess g
    • compute next approximation:
      • next_guess = g - (g^3 - X) / (3*g^2)
  • Emphasizes that only the next guess is computed (looping to repeat iterations isn’t covered yet).

• F-strings

  • F-string purpose: cleanly print mixed text and computed expressions.
  • Format:
    • f" ... {expression} ... "
  • Expressions inside {} are evaluated automatically and inserted.
  • Avoids:
    • awkward comma-separated print(...) spacing
    • manual casting to strings for concatenation
  • Expressions can be embedded “anywhere” within the output template.

---

Methodology / instructions (detailed)

A) Creating and using strings

• Create a string by enclosing characters in quotes:
  • "me", "my", "Musketeers", etc.
• Concatenate strings:
  • c = a + b
  • Note: no spaces unless you include them explicitly (e.g., a + " " + b)
• Repeat strings:
  • s2 = a * n (or n * a)
  • Ensure n is an integer (cast if needed).
• Get string length:
  • n = len(s)
• Index single characters:
  • ch = s[i]
  • Use i starting at 0
  • Use negative indices for from-the-end access:
    • s[-1] is last character
• Slice substrings:
  • sub = s[start:stop:step]
  • Rules:
    • stop is exclusive
    • step default is 1 if omitted
    • positive step slices left-to-right; negative step reverses direction
  • Common shorthand:
    • s[a:b] (implies step 1)
    • s[:] (whole string)
    • s[::-1] (reverse)
• Remember strings are immutable:
  • To “change” text, build a new string and reassign.

B) Printing output in scripts

• To display results in a file, wrap expressions with print(...):
  • print(len(s))
  • print(s[i])
• For multiple items on one line:
  • print(x, y, z)
  • Commas insert spaces automatically.
• For concatenation-like display (no auto spaces):
  • Use + and cast non-strings if needed:
    • print("Value: " + str(num))
• Prefer F-strings for mixed output:
  • print(f"Value: {num}%" )
  • Avoid extra spaces introduced by comma-separated print.

C) Collecting user input

• Prompt and capture input:
  • text = input("Prompt: ")
• Input is always a string:
  • If numeric behavior is needed:
    • num = int(input("Enter a number: "))
    • or num = float(input(...))
• Reuse the captured value in expressions:
  • For repeated output:
    • print(text * 5) if it’s a string
    • print(5 * num) if it’s an integer.

D) Building conditional branching logic

• Use if/elif/else with indentation:
  • if condition:
    • run this block
  • elif other_condition:
    • run this block if first was false
  • else:
    • run if none above were true
• Boolean comparisons return True/False:
  • use == (not =) for equality checks
• Combine conditions using Boolean operators:
  • A and B, A or B, not A
• Debugging principle:
  • Ensure prints meant for a particular case are indented inside the relevant block.
• Use:
  • if statements when multiple branches may run
  • if/elif/else when exactly one branch should run.

---

Speakers / sources featured

• Instructor / lecturer (unnamed)