Python Concepts

A program is a list of instructions that runs in order. Python reads those instructions, checks the syntax, and then executes them.

• The computer only does what the code says, not what we meant.
• Python uses indentation to show structure, so spacing matters.
• Comments help humans read code, but Python ignores them.

This concept gives students their mental model for everything else on the site. If they understand that Python runs clear, ordered instructions, later topics feel much less mysterious.

print("Welcome to Python")
print("Line 2 runs after line 1")

Students see that each line runs from top to bottom and produces visible output.

• Forgetting quotes around text
• Missing a closing parenthesis in print(...)
• Adding spaces before top-level code when no block has started

A variable is a label attached to a value. Instead of repeating the same value again and again, students give it a name and use that name later.

• Assignment uses = to store a value.
• Reassignment changes what the name points to.
• F-strings let students place variables inside sentences.

Variables are the bridge from one-line output to real programs. Once students can store and update values, they can model scores, names, totals, timers, and much more.

• Putting quotes around the variable name when you want the value
• Using spaces inside a variable name
• Forgetting the f in front of an f-string

A data type tells Python what kind of value it is working with. Numbers, text, and True/False values behave differently.

• int stores whole numbers
• float stores decimal numbers
• str stores text
• bool stores True or False

Students need this concept to predict program behavior. It explains why 3 + 4 works, why text needs quotes, and why some conversions need casting.

raw_temp = "21.5"
temp_c = float(raw_temp)
print(temp_c + 3)

The string must be converted before Python can do number math with it.

• Trying to add a string directly to a number
• Assuming floats behave exactly like integers
• Forgetting that input() returns text

Operators tell Python what action to perform between values. They cover arithmetic, string joining, and logical comparison.

• +, -, *, /, //, %, ** handle numeric work
• Comparison operators produce True or False
• Parentheses control the order of operations

Students use operators in nearly every lesson. They need them for formulas, conditions, score updates, and later algorithmic work.

• Forgetting operator precedence
• Using / when you wanted integer division //
• Mixing comparison logic with arithmetic without parentheses

Python ships with useful functions that students can call right away. These functions save time and make programs more expressive.

• print(...) shows output
• input(...) reads user text
• len(...), round(...), min(...), max(...) analyze or reshape values

This topic helps students move from fixed examples to interactive programs. It also introduces the habit of reaching for tools instead of rewriting everything by hand.

raw_price = input("Price? ")
price = float(raw_price)
print(f"${round(price, 2):.2f}")

Students can see the full path: read text, convert it, then format the final answer.

• Forgetting to cast input() before doing number math
• Writing len without parentheses
• Using the wrong function when a simpler built-in already exists

A string is text wrapped in quotes. Python treats it as an ordered sequence of characters, which means students can access one character or a range of characters.

• Indexing grabs one character
• Slicing grabs a range
• String methods create transformed versions of the text

Strings show up everywhere: names, prompts, file content, DNA sequences, messages, and menu labels. They are also a gentle introduction to sequence thinking.

raw = "  bridge academy  "
clean = raw.strip().title()
print(clean)

The original text stays the same; each method returns a cleaned-up version.

• Using an index that is out of range
• Forgetting that slice stop positions are excluded
• Expecting .replace() or .upper() to modify the original string automatically

A list is an ordered collection inside square brackets. Lists are mutable, so students can add, remove, and update elements as a program runs.

• Lists keep order
• Indexes start at 0
• Methods such as append, insert, sort, and pop change the list

Lists are the first place students manage many values at once. They are essential for scores, inventories, menus, playlists, time-series data, and later algorithms.

temps = [71, 74, 69]
temps.append(73)
avg = sum(temps) / len(temps)
print(f"{avg:.1f}")

The list grows first, then students use other tools to summarize it.

• Confusing an element with its index
• Writing values = values.sort() and losing the list
• Mutating a list when a copied version was intended

A dictionary stores pairs of related information. Instead of using positions like a list, students use keys such as 'name', 'capital', or 'price'.

• Keys must be unique
• Lookups happen by key, not by numeric position
• Methods like keys(), values(), items(), and get() help with iteration and safe access

Dictionaries feel closer to real data. They let students model records and labeled facts long before they are ready for databases or APIs.

prices = {"AAPL": 184.5, "MSFT": 410.2}
for ticker, price in prices.items():
    print(f"{ticker}: {price}")

The items() view is the cleanest way to loop over both keys and values together.

• Looking up a missing key without get()
• Assuming dictionary order works like list indexing
• Forgetting that looping over a dictionary alone gives keys

A tuple groups values together in a fixed order. It is useful when the shape of the data should stay stable, such as coordinates or measurement records.

• Tuples use parentheses
• They support indexing and slicing
• Unpacking assigns tuple items into separate variables

Tuples help students think about fixed records and multiple return values. They also prepare students for cleaner function outputs.

• Trying to change a tuple item with assignment
• Forgetting the comma in a one-item tuple
• Using a tuple where a list would be easier to update

A loop repeats a block of code. Students use loops when the same pattern needs to happen for each number, item, character, or record.

• for loops are great for known sequences
• while loops are great when a condition controls repetition
• Accumulators help build totals, counts, and other running results

Loops are where students start thinking algorithmically. Instead of solving one case, they write a pattern that solves many cases.

scores = [88, 91, 73, 95]
count = 0
for score in scores:
    if score >= 90:
        count += 1
print(count)

This example combines iteration, conditionals, and an accumulator in a way students will reuse often.

• Indenting the loop body incorrectly
• Forgetting to update the variable inside a while loop
• Resetting the accumulator inside the loop by accident

A conditional checks whether something is True or False, then chooses which block of code should run.

• if handles the first test
• elif adds extra branches
• else handles the fallback case

This is the core idea behind decisions in programming: grading rules, menu choices, validation, game logic, and filtering all depend on conditionals.

• Using = instead of == in a condition
• Writing overlapping branches in the wrong order
• Forgetting the colon at the end of if or elif

A function is a reusable mini-program with a name. It can take inputs, do work, and optionally return a result.

• def creates the function
• Parameters receive input values
• return sends a result back to the caller

Functions reduce repetition and make bigger programs easier to read. They also help students think in smaller, testable pieces.

def greet(name, punctuation="!"):
    print(f"Hello, {name}{punctuation}")

greet("Mia")
greet("Leo", "?")

Students can see both required and optional inputs without needing a long explanation.

• Forgetting to call the function after defining it
• Printing inside a function when a return value was needed
• Using variable names inside the function that were never passed in

Exceptions are Python's way of reporting errors. try/except lets students attempt risky code and choose how to respond if it fails.

• try contains the risky operation
• except catches specific error types
• Good handlers explain the problem or recover safely

Students stop being afraid of runtime errors when they understand what they mean and how to catch common ones such as ValueError or IndexError.

• Using a bare except for everything
• Catching the error but giving no useful message
• Assuming try/except replaces careful logic and validation

A list comprehension is a shorter way to create a list from another iterable. It can map values, filter values, or do both in one readable expression.

• expression comes first
• the for clause names each item
• an optional if clause filters items

This is a PCAP bridge topic because students already know the long form. Now they can compare concise syntax against the loop version and choose what reads best.

• Trying to cram too much logic into one expression
• Forgetting the order: expression, for, optional if
• Using a comprehension when a normal loop would be clearer

A lambda is a small anonymous function. It is often used when students need a quick rule to pass into another function.

• lambda is best for tiny one-expression functions
• sorted(..., key=...) is the most common beginner-friendly use
• map and filter apply a rule across data

This topic helps Level II students see that functions can be treated like data and passed around when needed.

• Using lambda for logic that deserves a named function
• Forgetting that map and filter return iterables in Python 3
• Writing a key function that returns the wrong comparison value

Python functions can accept variable numbers of arguments and can also be passed into other functions. This makes code more reusable and configurable.

• *args collects extra positional arguments
• **kwargs collects named arguments
• Functions can be stored, returned, and passed around

These patterns appear in frameworks, libraries, and reusable utilities. Students do not need them every day, but they help explain more advanced Python code.

• Forgetting that *args becomes a tuple
• Mixing positional and keyword argument order incorrectly
• Using clever higher-order patterns where plain code would be clearer

A class is a blueprint. An object is a specific thing created from that blueprint, carrying its own data and behavior.

• __init__ builds the starting state
• self refers to the current object
• Methods are functions attached to the class

Students meet OOP when programs grow beyond isolated functions. It is useful for modeling game pieces, bank accounts, students, robots, and other rich objects.

• Forgetting self in method definitions
• Trying to use instance attributes before creating them
• Mixing up class names and object names

File input/output is how programs work with data that lasts after the program stops running.

• open(...) creates a file connection
• read, readline, and write interact with the file contents
• with automatically closes the file when the block ends

This is the bridge from toy programs to real applications. Students start working with saved logs, reports, inputs, and generated outputs.

• Using the wrong file mode
• Assuming read() returns numbers instead of text
• Forgetting that newline characters may still be present

Beyond basic try/except, Python lets students control what happens after success, after failure, and during cleanup.

• else runs only when no exception happens
• finally runs whether an error happened or not
• raise creates an exception on purpose when the program detects a problem

This topic helps students move from merely catching errors to designing clear, reliable error behavior in larger codebases.

• Using raise without a clear message
• Putting success-only logic inside finally
• Catching broad exceptions so early that real bugs become harder to debug

A module is a Python file with code inside it. A package is a folder that groups related modules together.

• import brings names into the current file
• from ... import ... loads a more specific name
• Modules let students separate reusable code from main scripts

Students meet this concept when projects stop fitting in one file. It also explains how Python accesses tools like math, random, or datetime.

• Naming a student file the same as a standard library module
• Forgetting which names came from which import style
• Writing everything in one file when a helper module would be cleaner