Python Reference

# print() adds a newline by default
print("Hello, World!")

# Run a Python script directly
python3 main.py

# Single-line comment for brief notes

""" Multi-line 
    comment block or Docstring for documentation """

import sys # System-specific parameters and functions
import os  # Miscellaneous operating system interfaces
from datetime import datetime # Import specific class from module
from math import pi as PI_CONST # Aliasing for shorter access

import sys
# exit(0) for success, non-zero for error (e.g., 1)
sys.exit(1) 

try:
    # Attempt division by zero
    result = 10 / 0
except ZeroDivisionError as e:
    # Catch and print the specific error
    print(f"Error: {e}")
finally:
    # Always executed regardless of exception
    print("Cleanup")

x = 5 # Integer
name = "Python" # String
MAX_VAL = 100 # Constant by convention (capitalized)

import sys
# Max size of a signed word on the current platform
print(sys.maxsize) 

i = int(3.14)      # Float to int (3)
f = float("1.23")  # String to float (1.23)
s = str(100)       # Int to string ("100")

import os

# Retrieve environment variable value
path = os.getenv("PATH")
# Set environment variable for current process
os.environ["API_KEY"] = "secret"

import time
from datetime import datetime

# Performance measurement using monotonic clock
start = time.perf_counter()
elapsed = time.perf_counter() - start

# Time formatting
now = datetime.now()
print(now.isoformat()) # ISO 8601 representation
print(now.strftime("%Y-%m-%d %H:%M:%S")) # Custom format

a = 10 / 3  # True division (3.333)
b = 10 // 3 # Floor division (3)
c = 10 ** 3 # Power operator (1000)
d = True and False # Logical AND (False)

import re

text = "The price is $100"
# Search for pattern in text
match = re.search(r"\$(\d+)", text)
if match:
    print(match.group(1)) # Print first captured group: "100"

import argparse

parser = argparse.ArgumentParser()
parser.add_argument("-v", "--verbose", action="store_true") # Boolean flag
parser.add_argument("-o", "--output", required=False)      # Optional valued argument
parser.add_argument("input", help="Source file")           # Mandatory positional argument

# Parse arguments from sys.argv
# args = parser.parse_args() 

def add(a, b=0):
    """Function with optional parameter and docstring"""
    return a + b

# Multi-return via implicit Tuple packing/unpacking
def get_status():
    return 200, "OK"

code, msg = get_status()

def modify(l):
    # Modifies the original list object in place
    l.append(4) 

my_list = [1, 2, 3]
modify(my_list) # my_list is now [1, 2, 3, 4]

x = 10
if x > 5:
    print("Greater")
elif x == 5:
    print("Equal")
else:
    print("Less")

val = 2
match val:
    case 1:
        print("One")
    case 2 | 3:
        print("Two or Three")
    case _:
        print("Other")

# Range-based for loop (0 to 2)
for i in range(3):
    print(f"for: {i}")

x = 0
while x < 3:
    print(f"while: {x}")
    x += 1

for x in range(10):
    if x < 2: continue # Skip iteration
    if x == 5: break    # Exit loop
    print(x)

# Iterating over List
for val in [10, 20]:
    print(val)

# Iterating over Dictionary items
for k, v in {"a": 1}.items():
    print(f"{k}: {v}")

s = "  hello  "
s = s.strip().capitalize() # Remove whitespace and uppercase first letter: "Hello"
sub = s[0:2] # String slice: "He"
joined = "-".join(["a", "b"]) # Join list into string: "a-b"

import os
from pathlib import Path

# Legacy OS-specific path joining
p1 = os.path.join("/", "usr", "bin")
# Modern object-oriented path handling
p2 = Path("/") / "usr" / "bin" 

# Open binary file for reading
with open("data.bin", "rb") as f:
    # Read in fixed-size chunks
    while chunk := f.read(4096):
        # Process the binary chunk
        pass

# Open text file using context manager
with open("file.txt", "r") as f:
    # Read entire content into memory as string
    content = f.read()

import struct

# Create mutable bytearray buffer
buf = bytearray(12)

# Pack values into buffer: ! (Big-Endian), i (int32), d (double)
struct.pack_into("!id", buf, 0, 42, 3.14)

res = 0b1010 & 0b1100 # Bitwise AND
res = 0b1010 | 0b1100 # Bitwise OR
res = 0b1010 ^ 0b1100 # Bitwise XOR
res = ~0b1010         # Bitwise NOT (complement)
res = 0b0001 << 2     # Bitwise Shift Left (0b0100)

# Format integer as hex string
s = hex(255) # "0xff"
# Parse hex string to integer
val = int("ff", 16) # 255

l = [1, 2]; l.append(3) # Dynamic List (append)
d = {"k": "v"}; val = d["k"] # Dictionary (Key access)
s = {1, 1, 2} # Set (Automatic deduplication: {1, 2})

import json

# Parse JSON string into Python dictionary
data = json.loads('{"id": 42}')
# Serialize Python dictionary to JSON string
s = json.dumps(data)

import socket

# TCP Server setup
srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
srv.bind(('0.0.0.0', 8080)); srv.listen(1)

# TCP Client request
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect(("example.com", 80))
    s.sendall(b"GET / HTTP/1.0\r\n\r\n")

import socket

# Create UDP socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Send datagram without connection
s.sendto(b"ping", ("127.0.0.1", 8080))

import threading

def fn(): print("Task running")

# Spawn and start a background thread
t = threading.Thread(target=fn)
t.start(); t.join()

import sqlite3

# Connect to an in-memory database
db = sqlite3.connect(":memory:")
# Execute DDL command
db.execute("CREATE TABLE t(id)")
# Execute query and fetch result
res = db.execute("SELECT 42").fetchone()
print(res[0])