vinix24/vnx-orchestration/python-optimizer

# Memory-efficient HTML parsing
from lxml import etree
# Use iterparse for large HTML
for event, elem in etree.iterparse(html_file, tag='div'):
    process(elem)
    elem.clear()  # Free memory immediately
    while elem.getprevious() is not None:
        del elem.getparent()[0]
# Efficient string operations
# BAD: String concatenation in loop
result = ""
for item in items:
    result += str(item)
# GOOD: Join method
result = "".join(str(item) for item in items)

# Batch database operations
# BAD: Individual inserts
for record in records:
    cursor.execute("INSERT INTO table VALUES (?)", record)
# GOOD: Batch insert
cursor.executemany("INSERT INTO table VALUES (?)", records)
# Use connection pooling
from contextlib import contextmanager
@contextmanager
def get_db_connection():
    conn = connection_pool.get_connection()
    try:
        yield conn
    finally:
        connection_pool.return_connection(conn)

# Use pandas efficiently
import pandas as pd
# BAD: Iterating over DataFrame rows
for index, row in df.iterrows():
    df.at[index, 'new_col'] = process(row['old_col'])
# GOOD: Vectorized operations
df['new_col'] = df['old_col'].apply(process)
# BETTER: NumPy operations when possible
df['new_col'] = np.vectorize(process)(df['old_col'].values)
# Memory-efficient DataFrame operations
# Read in chunks
for chunk in pd.read_csv('large_file.csv', chunksize=1000):
    process_chunk(chunk)

# 1. Use itertools for memory efficiency
import itertools
# Chain iterables without creating intermediate lists
combined = itertools.chain(iter1, iter2, iter3)
# 2. Weak references for caches
import weakref
cache = weakref.WeakValueDictionary()
# 3. Memory-mapped files for large data
import mmap
with open('large_file', 'r+b') as f:
    with mmap.mmap(f.fileno(), 0) as mmapped_file:
        # Work with file as if in memory
        data = mmapped_file[0:1000]

# 1. Early returns
def process(item):
    if not item:
        return None  # Early return
    # Complex processing only if needed
# 2. Lazy evaluation
@property
def expensive_property(self):
    if not hasattr(self, '_cached'):
        self._cached = expensive_calculation()
    return self._cached
# 3. Set operations for membership testing
# BAD: O(n) lookup
if item in large_list:
    pass
# GOOD: O(1) lookup
large_set = set(large_list)
if item in large_set:
    pass

# Timing decorator
import time
from functools import wraps
def timeit(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__}: {end - start:.4f}s")
        return result
    return wrapper
# Memory tracking
import tracemalloc
tracemalloc.start()
# Code to profile
current, peak = tracemalloc.get_traced_memory()
print(f"Current: {current / 1024 / 1024:.1f}MB")
print(f"Peak: {peak / 1024 / 1024:.1f}MB")
tracemalloc.stop()

🔧 Skill actief: python-optimizer