CS50P - Lecture 0 - Functions, Variables

Main ideas / lessons

• Programming is text: Python code is plain text stored in files, typically ending in .py.
• Use a text editor + terminal (CLI):
  • Write code in an editor (e.g., VS Code).
  • Run it using a command-line interface (CLI).
• Python works via interpretation:
  • The Python interpreter reads code top-to-bottom, left-to-right and runs it by translating it into what the computer can execute.
• First program: “Hello, world”:
  • The print(...) function outputs text to the screen.
  • The text given to print is controlled by arguments.
  • Output is a side effect (a visible result produced by the function).
• Bugs and syntax errors are expected:
  • A bug is a mistake.
  • A missing parenthesis triggers a syntax error; error messages guide debugging.
• Inputs and interactivity:
  • input(...) prompts the user and returns what they type.
  • input expects text (strings).
• Variables store values so returned inputs can be reused:
  • Use assignment with = (assignment operator, not equality).
  • Example pattern:
    • name = input(...)
    • then reuse name in print.
• Formatting strings properly:
  • Plain "Hello, {comma} name" prints the literal text—variables won’t substitute automatically.
  • Correct approaches demonstrated:
    • string concatenation with +
    • multiple arguments to print (Python inserts spacing by default)
    • sep and end parameters to control spacing/newlines
    • f-strings: f"Hello, {name}"
• Comments and pseudo-code:
  • Comments (using # or sometimes triple quotes) are ignored by Python; they help humans understand code.
  • Pseudo-code: outlining logic in English before implementing.
• String methods (built-in behavior on strings):
  • strip() removes whitespace at both ends.
  • capitalize() changes only the first letter.
  • title() capitalizes each word like book titles.
  • Methods can be chained: e.g., name.strip().title().
• More string manipulation:
  • split(...) divides a string into parts (e.g., first name / last name).
  • Multiple assignment can unpack results: first, last = name.split(" ").
• Other data types introduced:
  • int (integers): whole numbers.
  • float (floating-point): decimals.
• Math operators and modulo:
  • + - * / for arithmetic, and % for remainder (modulo).
• Interactive mode:
  • Python can run code line-by-line in an interactive REPL (no need to edit/run files repeatedly).
• Building a calculator:
  • Initial calculator bug: using + with inputs treated as strings results in concatenation (e.g., "1" + "2" -> "12"-like behavior).
  • Fix: convert inputs to numbers using:
    • int(input(...)) for integer math
    • float(input(...)) for decimal math
  • Demonstrated nested calls and reducing variables.
• Rounding floats:
  • Use round(number) or round(number, digits) to round.
  • Mentioned f-string numeric formatting for comma-separated thousands (locale-aware): e.g., f"{Z:,}".
• Division & floating point precision:
  • 2/3 produces a repeating decimal; floats show limited precision.
• Defining your own functions:
  • Use def to create functions.
  • Functions can take parameters and can use return values.
  • Default parameter values supported:
    • def hello(to="world"):-style concept.
• Code organization: scope and main:
  • Variables are only available within their scope (e.g., a variable defined in main isn’t automatically visible inside another function).
  • A common structure:
    • define helper functions (hello, square, etc.)
    • define main()
    • call main() at the end so code actually runs
• Function composition example: square:
  • Implement square(N) returning N * N (or equivalent).
  • Use return so other code (like print) can use the computed value.

---

Methodologies / instruction-style takeaways (detailed bullets)

1) How to run a Python program (workflow)

• Install and use:
  • a text editor (e.g., VS Code) to create .py files
  • Python interpreter available on your system
• Create a file like:
  • hello.py
• In the terminal/CLI, run:
  • python hello.py

2) Build “Hello, world” using print

• Write:
  • print("Hello, world")
• Ensure syntax is correct (e.g., balanced parentheses and quotes).
• Run the file with python hello.py.
• Expect a side effect: the output appears on screen.

3) Make the program interactive using input

• Prompt the user:
  • name = input("What's your name? ")
• Then use the returned value:
  • print("Hello,", name) (or other string-formatting methods)

4) Properly include a variable inside text

Choose one approach:

• f-string (recommended for variable substitution):
  • print(f"Hello, {name}")
• Concatenation:
  • print("Hello, " + name)
• Multiple print arguments:
  • print("Hello, ", name)
  • (note: Python inserts a default separator space between arguments)
• Control spacing/newlines with print parameters:
  • sep: separator between multiple arguments (default is a space)
  • end: what ends the output line (default is newline \n)
  • Example pattern to avoid newline:
    • first print(..., end=""), then a second print(...)

5) Clean up user input using string methods

• Remove extra leading/trailing whitespace:
  • name = name.strip()
• Fix capitalization style:
  • name = name.title() (book/title capitalization)
• Chain transformations:
  • name = name.strip().title()

6) Split a full name into parts

• Split by a delimiter (e.g., space):
  • first, last = name.split(" ")
• Use the selected part:
  • print(f"Hello, {first}")

7) Convert user input strings into numbers (calculator)

• If you want integer math:
  • x = int(input("What's X? "))
  • y = int(input("What's Y? "))
  • then print(x + y) (numeric addition)
• If you want decimals:
  • x = float(input(...))
  • y = float(input(...))

8) Round numeric results

• Round to nearest integer:
  • round(value)
• Round to N decimal places:
  • round(value, N)

9) Write your own functions with def

• Define a function:
  • def hello():
  • Indent the body under def.
• Call the function later in code:
  • hello()
• Parameterized function:
  • def hello(to):
  • use to inside the function
• Default argument:
  • def hello(to="world"):
• Return a value:
  • return something
  • (so other code can use the result)

10) Organize programs with main() and avoid scope mistakes

• Define helpers first (or anywhere, but ensure they’re defined before use if called at import time).
• Put the running logic in:
  • def main(): ...
• Call at the bottom:
  • main()
• Pass values into functions rather than assuming shared variables:
  • variables created inside main must be passed as parameters if needed elsewhere.

---

Speakers / sources featured

• David Malan (CS50 instructor; host/narrator in the subtitles)
• Python documentation (referenced as an official source via docs.python.org)
• Python interpreter / built-in Python functions (e.g., print, input, round, int, float, split, string methods like strip/title/capitalize, f-strings)