Comprehensive Python Fundamentals Notes from Transcript

Fundamental Vocabulary and Data Types

• Value: anything that a program can manipulate (e.g., a number, a word, etc.). In Python, values are represented by objects.
• Object: an entity in memory created from a class; everything in Python is an object (seed idea for later in the course).
• Class: the blueprint for an object; in Python this is often referred to as a data type.
• Data Type: synonym for a class in Python (e.g., int, float, str, bool).
• type() function: used to determine the underlying type of a value.
  • Example: the type of a string literal is a string type. If you have a value like "I'm a cat", then
  • $\text{type}("I'm a cat") = <class 'str'>$
• Common basic types:
  • Integer: a number without a decimal point (e.g., $3, 42, 1000$).
  • Float (floating point number): a number with a decimal point (e.g., $3.14159$).
  • String: text data (e.g., $"cat", "123"$). Quotes distinguish strings from numbers.
  • Boolean: explicit true/false values (in Python, $True$ and $False$, not lowercase true/false).
• Example distinction between types:
  • The integer 3 vs. the string "3" have different types and support different operations.
  • Printing or operating on them will yield different results because of their types.
  • Example: print(3) vs. print("3") produce differently typed outputs, and arithmetic on them is not interchangeable.

Python Objects, Types, and Printing Demos

• You can create values and print their types:
  • $\text{type}("hello world") = <class 'str'>$
  • $\text{type}(3) = <class 'int'>$
  • $\text{type}(3.0) = <class 'float'>$
  • $\text{type}(True) = <class 'bool'>$
• Print statements and strings:
  • If you print a string, you see the text (e.g., $print("Hello")$ outputs: Hello).
  • If you print a number, you see the numeric value (e.g., $print(3)$ outputs: 3).
• Important note about strings vs numbers:
  • A string "3" is not the same as the integer 3. Their types are different and Python treats them differently in operations.

Type Conversion Functions

• Python provides conversion functions to coerce values to a target type:
  • $\text{int}(x)$ converts to an integer (base 10 by default for decimal strings and numbers).
  • $\text{float}(x)$ converts to a floating-point number.
  • $\text{str}(x)$ converts to a string.
  • $\text{bool}(x)$ converts to a boolean: for most values, nonzero/non-empty values evaluate to True, and empty/zero values evaluate to False.
• Examples and caveats:
  • $\text{int}("123") = 123$
  • $\text{int}("cats")$ would raise an error because the string does not represent a number.
  • $\text{float}("3.14") = 3.14$
  • $\text{float}("cats")$ would raise an error.
  • $\text{str}(123) = "123"$
  • $\text{bool}(0) = \text{False}, \text{bool}(2) = \text{True}$; for many objects, an empty container or zero evaluates to False.
• Numerical bases (brief): Python’s int() can parse with a specified base, e.g., $\text{int}("1010", 2) = 10$; mention that you can work with bases like 2 (binary), 8 (octal), 16 (hex) when needed. The transcript mentions different bases as a concept (base 10, base 2, base 16) and notes that some numbers/words (like "cats") aren’t meaningful in those contexts for plain int("…") conversions.

Booleans and Logical Thinking

• Boolean type represents True or False values:
  • The Python booleans are the capitalized literals $True$ and $False$.
  • Example: $bool(2 + 3) = True$ because the expression 2 + 3 evaluates to 5, and in a boolean context any nonzero value is True.
  • Example: $bool(3 - 3) = False$ because the result is 0, which is False in a boolean context.

Variables and Assignment

• Assignment creates a new variable and assigns a value to it using the single equals sign: $name = value$.
• Important distinction: assignment is not equality testing. Equality testing uses the double equals: $a == b$.
• Example:
  • $val1 = 12$ assigns the integer 12 to the variable val1.
  • After this, you can use val1 in expressions.
• A variable must have a value before it can be used; using an uninitialized variable results in an error.
• Variable naming rules (and pitfalls):
  • No spaces in identifiers: e.g., $my val = 3$ is invalid.
  • Identifiers can start with underscores: $_my_val = 3$ is valid.
  • Digits can appear after the first character (e.g., $my_val2$).
  • Keywords cannot be used as variable names (e.g., $break$, $lambda$, $if$ are reserved).
  • There is a set of reserved keywords in Python; you’ll learn them as you go.

Statements vs Expressions

• Statement: an instruction the Python interpreter can execute (e.g., print, if, for, while).
• Expression: a combination of values, variables, operators, and function calls that evaluates to a value.
• Examples:
  • A statement: $print(1 + 2)$ — the whole line is a statement; the expression inside is $1 + 2$ which evaluates to 3.
  • An expression: $len("cats")$ evaluates to the number of characters in the string, which is 4 in Python (the transcript notes 3, which is a small error; the actual result is 4).
• Printing and evaluation:
  • When you run a program that prints, you may need to explicitly call print() to see output, because just placing an expression on a line does not automatically display it.
• A worked example from the transcript:
  • Print statements and type inspection:
  • The transcript shows a scenario where you print values and also print their types to observe the difference between integers and strings.

Operator Precedence and Evaluations (PEMDAS)

• Python follows an order of operations, similar to PEMDAS (Parentheses, Exponents, Multiplication/Division, Addition/Subtraction, with comparisons later in the chain):
  • Parentheses first: evaluate expressions inside ()
  • Exponents: use the operator ** for exponentiation
  • Multiplication and Division: evaluated from left to right
  • Addition and Subtraction: evaluated from left to right
  • Comparisons (
• Associativity: operators with the same precedence are evaluated left-to-right (except for exponentiation, which is right-associative in Python)
• A sample precedence-related reasoning from the transcript:
  • The transcript shows a numeric expression to illustrate order of operations and the idea of evaluating step-by-step rather than all at once.
• A simple, clarified PEMDAS example (for reference):
  • Suppose we evaluate $2 + 3 * 4$
  • Multiplication first: $3 * 4 = 12$
  • Then addition: $2 + 12 = 14$
• The transcript’s specific step-by-step example (as described):
  • Given: a = 24 - 3 * 8
  • Step 1: $3 \times 8 = 24$
  • Step 2: $24 - 4 = 20$
  • Step 3: $20 + 2 = 22$
  • Note: The transcript’s narrative contains a minor inconsistency in how the intermediate values (like the 4) are introduced, but the intended takeaway is to perform multiplication first, then subtraction, then addition, following the order of operations and left-to-right evaluation for same-precedence operators.

Current Working Directory (cwd) and VS Code Tips (Lab Setup)

• Current Working Directory: the folder from which your code runs by default. It matters for file I/O and relative paths.
• In VS Code (as described in the transcript):
  • Open the correct folder for the class projects (e.g., a folder path like com_s127 or similar).
  • Use the integrated terminal (toggle with Ctrl+on Windows/Linux or Cmd+ on macOS).
  • Use pwd (print working directory) on macOS to verify your path; on Windows, you can use a path display or an equivalent command.
• Creating files for a lab:
  • Create a new file (e.g., demo1.5.py).
  • At the top, include a comment block with your name, date, and a description of what the code does, e.g.:
  • # Name: Your Name
  • # Date: 01/2013 -> 08/2025 (as in the transcript example; use current dates)
  • # Description: Variables, demo for Python basics
  • Use Python comments with the hash symbol (#) to ignore non-code lines.
• Running and saving:
  • After editing, save changes (Ctrl+S on Windows/Linux, Cmd+S on macOS).
  • The transcript shows a small cue of an unsaved change indicator (a white dot) that disappears after saving.

Code Documentation and Style (Comments in Python)

• Comments are started with # and are ignored by Python.
• A good practice shown in the transcript: include
  • Your name
  • A description of what the file does
  • The date or version information
• Documentation improves readability and helps you track changes across past/present/future work (as a humorous analogy in the lecture).

Identifiers, Keywords, and Naming Rules

• Identifiers (variable names) must follow Python’s rules:
  • No spaces (use underscores to separate words, e.g., myval, totalcount).
  • Can start with an underscore or a letter; cannot start with a digit.
  • Can include digits after the first character (e.g., val1, data2).
  • Cannot use Python keywords as identifiers (e.g., break, lambda, if).
• The transcript mentions examples: myval is valid; my val is not; myval$ is not (special characters besides underscore are not allowed).

Practical Takeaways and Study Pointers

• Understand the significance of types and how Python treats values differently based on type.
• Use type() to inspect the type of a value and len() to inspect the length of a string.
• Distinguish between statements (instructions) and expressions (that evaluate to a value).
• Practice variable creation via assignment and remember that using an uninitialized variable causes errors.
• Be mindful of the difference between strings and numbers when performing operations (e.g., + on strings concatenates, on numbers adds).
• Use print() to display values and their types to build intuition during early lessons.

Quick Reference: Core Python Concepts from the Transcript

• Core data types: int, float, str, bool
• Type inspection: $\text{type}(x)$
• Type conversion: $\text{int}(x), \text{float}(x), \text{bool}(x), \text{str}(x)$
• Printing: $\text{print}(\text{value})$
• Length of strings: $\text{len}(\text{string})$
• Assignment: $name = value$
• Equality vs. assignment:
  • Assignment: $name = value$
  • Equality check: $name == value$
• Expressions vs statements:
  • Expression example: $1 + 2$ (evaluates to 3)
  • Statement example: $\text{print}(1 + 2)$ (prints 3)
• Operator precedence (summary):
  • Exponentiation: $**$ (highest among arithmetic operators in Python)
  • Multiplication/Division: left-to-right
  • Addition/Subtraction: left-to-right
  • Parentheses override precedence
• Booleans: $True, False$ (capitalized)
• Keywords: reserved words like $break, lambda, if, else, for, while$; avoid using them as identifiers