Primitive Data Types and Assignment

Python utilizes dynamic typing for variable assignment. Common primitvie types include integers, floating-point numbers, strings, and boolean values.

user_age = 28              # int
pi_value = 3.14159         # float
location = "Tokyo"         # str
is_subscribed = False      # bool

Built-in Collection Types

The language provides several high-level data structures for organizing information efficient.

queue_tasks = ["compile", "test", "deploy"]       # list
grid_position = (10, 20, 30)                       # tuple
server_config = {"host": "localhost", "port": 8080} # dict
active_sessions = {1001, 1002, 1003}               # set

Control Flow and Iteration

Conditional branching and looping mechanisms dictate program execution paths.

Conditional Logic

speed = 85
if speed > 120:
    print("Excessive speed")
elif speed > 60:
    print("Within legal limits")
else:
    print("Low speed")

Iterative Structures

for item in ["alpha", "beta", "gamma"]:
    print(item.upper())

cycle = 0
while cycle < 4:
    print(f"Cycle {cycle}")
    cycle += 1

Function Encapsulation

Functions group executable logic into reusable units, supporting parameter passing and return values.

def compute_discount(price: float, rate: float) -> float:
    return price * (1 - rate)

Input and Output Routing

Standard I/O operations facilitate console interaction.

print(f"Processing request for {__name__}")
response = input("Enter confirmation code: ")

File System Interaction

Reading and writing persistent data is managed through standard file objects.

with open("audit.log", "w", encoding="utf-8") as log_file:
    log_file.write("System startup complete\n")

with open("audit.log", "r", encoding="utf-8") as read_file:
    records = read_file.readlines()
    print(records)

Exception Management

Robust applications anticipate and handle runtime errors gracefully.

try:
    parsed_val = int("invalid_input")
except ValueError as err:
    print(f"Parsing failed: {err}")
else:
    print("Conversion succeeded")
finally:
    print("Resource cleanup complete")

Module Import System

External code is integrated via imports, supporting aliasing and selective loading.

import datetime as dt
current = dt.datetime.now()

from math import ceil
print(ceil(4.2))

Comprehensions and Generators

Concise syntax exists for constructing sequences and evaluating data streams.

mapped_values = {num: num ** 3 for num in range(1, 5)}
filtered_set = {x for x in range(20) if x % 5 == 0}
aggregated = sum(n * 3 for n in range(6))

Function Decorators

Decorators wrap existing functions to inject additional behavior without modifying the original source.

def track_execution(func):
    def wrapper(*args, **kwargs):
        print(f"[Trace] Invoking {func.__name__}")
        result = func(*args, **kwargs)
        return result
    return wrapper

@track_execution
def format_output(text):
    return text.strip().upper()

print(format_output("  hello world  "))

Object-Oriented Design

Classes define blueprints for objects, supporting inheritance and method overriding.

class Device:
    def __init__(self, model_id, brand):
        self.model = model_id
        self.vendor = brand

class Smartphone(Device):
    def __init__(self, model_id, brand, os_version):
        super().__init__(model_id, brand)
        self.os = os_version

    def display_specs(self):
        return f"{self.vendor} {self.model} running {self.os}"

phone = Smartphone("X12", "TechCorp", "v14.1")
print(phone.display_specs())

Custom Exception Definitions

Developers can raise application-specific errors to enforce business logic constraints.

class AccessDeniedError(Exception):
    pass

def verify_permission(role):
    if role != "admin":
        raise AccessDeniedError("Operation restricted to administrators")
    return True

try:
    verify_permission("guest")
except AccessDeniedError as e:
    print(f"Security violation: {e}")

Context Management Protocols

The __enter__ and __exit__ methods enable automatic resource acquisition and release using the with statement.

class SessionHandler:
    def __init__(self, endpoint):
        self.endpoint = endpoint

    def __enter__(self):
        print(f"Connecting to {self.endpoint}")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"Disconnecting from {self.endpoint}")
        return False

with SessionHandler("db.server.local") as conn:
    print("Executing query...")