C C++ CSS Full Stack HTML JavaScript Node PHP PYTHON React

PYTHON · LESSON 52

Security, Performance and Memory Basics

Avoid common security mistakes and measure performance before optimising.

Level: Beginner to Advanced

Duration: ~60 Mins Deep-Dive

Updated: 26 Jul 2026

Lesson 52: Security, Performance and Memory Basics

1. Introduction to Enterprise System Hardening & Optimization

In Lesson 51, we mastered building CLI applications, packaging projects using pyproject.toml, and distributing packages via PyPI. However, when software transitions from local development workstations into enterprise cloud deployments, it faces two critical real-world pressures: Malicious Security Threats and Resource Scaling Constraints.

An application that functions correctly under normal testing conditions can still fail catastrophically if it suffers from security vulnerabilities (such as command injection or hardcoded credentials), execution bottlenecks that consume 100% CPU, or memory leaks that trigger Out-Of-Memory (OOM) operating system kernel panics.

In this lesson, we will explore core security practices (mitigating command injection, avoiding dangerous dynamic evaluation functions like eval() and pickle, managing secrets safely via environment variables), performance profiling using Python's standard `cProfile` module, memory tracking using `tracemalloc`, class memory optimization using `__slots__`, and routing security/performance diagnostic metrics using Structural Pattern Matching (`match-case`).

2. Common Security Vulnerabilities & Defense Mechanics

Enterprise Python applications must adhere to secure coding standards to defend against critical OWASP vulnerabilities:

1. Insecure Dynamic Code Execution (`eval()` and `exec()`)

Executing raw user strings directly via eval() or exec() allows attackers to inject arbitrary Python bytecode, execute shell commands, read host environment keys, or wipe system file systems.

2. Command Injection Vulnerabilities (`subprocess`)

Passing user input strings directly into os.system() or setting shell=True in subprocess.run() allows malicious operators to append shell command separators (like ; or &&) and execute unauthorized system instructions.

The `shell=True` Security Risk: NEVER execute subprocess.run("ls " + user_input, shell=True)! Passing a string with shell=True hands execution control to the system shell interpreter. Always set shell=False (the default) and pass arguments as an explicit sequence list: subprocess.run(["ls", clean_input])!

3. Insecure Deserialization (`pickle` Module)

Python's built-in pickle module allows serializing arbitrary Python objects to byte streams. However, unpickling untrusted data streams allows construction of custom __reduce__() payload objects that execute arbitrary shell commands automatically upon loading! Use secure JSON or Protocol Buffers instead.

4. Hardcoded Secret Keys vs Environment Variables (`python-dotenv`)

Hardcoding database passwords, API tokens, or cryptographic keys inside source code risk committing sensitive secrets to public version control repositories (Git). Enterprise security requires reading configuration parameters dynamically from host environment variables or .env files using os.environ.

SECURE_SECRETS_DEMO.PY

import os
import subprocess

# 1. SECURE SECRET HANDLING: Reading configuration from environment variables
DATABASE_URL = os.environ.get("DATABASE_URL", "sqlite:///default_local.db")
API_KEY_SECRET = os.environ.get("API_KEY_SECRET", "DEV_FALLBACK_KEY_ONLY")

def execute_secure_system_ping(host_address: str) -> str:
    """
    Executes system ping safely without shell injection vulnerabilities.
    Uses argument list array with shell=False strictly!
    """
    # Sanitize & validate host format
    clean_host = host_address.strip()
    if not clean_host.replace(".", "").isalnum():
        raise ValueError(f"Invalid host address character format: '{clean_host}'")

    # SECURE SUBPROCESS: Argument list with shell=False prevents command injection!
    cmd_args = ["ping", "-c", "1", clean_host]
    
    print(f"[SECURITY AUDIT] Executing command list: {cmd_args} (shell=False)")
    # Simulation return without invoking OS shell
    return f"Ping sequence initiated for '{clean_host}' safely."

print("=== Demonstration of Secure Configuration and Subprocess Calls ===")
print("Loaded DB URL  :", DATABASE_URL)
print("Execution Result:", execute_secure_system_ping("127.0.0.1"))

OUTPUT

=== Demonstration of Secure Configuration and Subprocess Calls ===
Loaded DB URL  : sqlite:///default_local.db
[SECURITY AUDIT] Executing command list: ['ping', '-c', '1', '127.0.0.1'] (shell=False)
Execution Result: Ping sequence initiated for '127.0.0.1' safely.

3. Performance Profiling: Identifying CPU Bottlenecks (`cProfile`)

When an enterprise service exhibits slow response times, guessing which function causes the delay is inefficient. Software engineers rely on deterministic Performance Profilers to measure exact function invocation frequencies and CPU execution time spent across call trees.

Python includes a deterministic C-based profiler: `cProfile`.

1. Running `cProfile` from Command Line and Programmatically

# Profiling a complete Python script from the CLI:
python -m cProfile -s cumulative application_script.py

CPROFILE_PERFORMANCE_DEMO.PY

import cProfile
import pstats
import io

def expensive_computation_task():
    """Simulates CPU-bound bottleneck loop."""
    return sum(i * i for i in range(100_000))

def light_utility_task():
    """Simulates fast utility execution."""
    return [x for x in range(100)]

def run_application_workload():
    for _ in range(5):
        expensive_computation_task()
        light_utility_task()

# Programmatic Profiling Execution using cProfile
profiler = cProfile.Profile()
profiler.enable()

# Executing target workload
run_application_workload()

profiler.disable()

# Formatted Summary Output Stream
stream = io.StringIO()
stats = pstats.Stats(profiler, stream=stream).sort_stats("cumulative")
stats.print_stats(5)  # Display top 5 time-consuming functions

print("=== Top Function Call Performance Profile ===")
# Displaying first 6 lines of stats summary report
print("\n".join(stream.getvalue().split("\n")[:8]))

OUTPUT

=== Top Function Call Performance Profile ===
         17 function calls in 0.012 seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.012    0.012 :1()
        1    0.000    0.000    0.012    0.012 cprofile_performance_demo.py:12(run_application_workload)
        5    0.012    0.002    0.012    0.002 cprofile_performance_demo.py:5(expensive_computation_task)

4. Memory Footprint Analysis (`tracemalloc` & `sys.getsizeof`)

In high-scale services, memory allocation leaks occur when objects remain referenced in global containers long after they are needed, forcing the Operating System to swap RAM to disk and eventually crashing processes.

1. Low-Level Object Sizing: `sys.getsizeof()`

The sys.getsizeof(obj) function returns the exact memory allocation size (in bytes) occupied directly by an individual Python object in system RAM.

2. Heap Tracking via `tracemalloc`

The standard library's `tracemalloc` module tracks memory block allocations created by Python interpreter subsystems, taking memory snapshots before and after operations to measure precise memory growth!

TRACEMALLOC_MEMORY_DEMO.PY

import tracemalloc
import sys

# 1. Inspecting individual memory sizes via sys.getsizeof()
small_list = [i for i in range(10)]
large_list = [i for i in range(10_000)]

print("=== 1. Low-Level Object Byte Size Inspection ===")
print("Small List (10 items)    :", sys.getsizeof(small_list), "bytes")
print("Large List (10,000 items):", sys.getsizeof(large_list), "bytes")

# 2. Tracking System Memory Allocations via tracemalloc
tracemalloc.start()

# Snapshot 1: Initial Baseline
snapshot_before = tracemalloc.take_snapshot()

# Allocating large transient dataset in memory
allocated_dictionary = {f"KEY_{i}": f"VALUE_PAYLOAD_{i}" for i in range(50_000)}

# Snapshot 2: Post Allocation
snapshot_after = tracemalloc.take_snapshot()

# Computing Memory Differential Stats
stats = snapshot_after.compare_to(snapshot_before, "lineno")

print("\n=== 2. Memory Allocation Snapshot Differential ===")
for stat in stats[:2]:
    print(f"File/Line: {stat.traceback[0]} | Memory Growth: +{stat.size_diff / 1024:.2f} KB")

tracemalloc.stop()

OUTPUT

=== 1. Low-Level Object Byte Size Inspection ===
Small List (10 items)    : 136 bytes
Large List (10,000 items): 85176 bytes

=== 2. Memory Allocation Snapshot Differential ===
File/Line: tracemalloc_memory_demo.py:19 | Memory Growth: +4320.50 KB

5. Class Memory Optimization using `slots`

By default, Python classes store instance attributes inside a dynamic dictionary object named __dict__ attached to each instance. While __dict__ allows adding new instance attributes dynamically at runtime, it carries significant memory overhead (~100 to 150 bytes of hash table dictionary metadata per individual object instance!).

When an enterprise application instantiates millions of domain objects (e.g., telemetry metrics, financial stock trades, or user records), storing attributes inside __dict__ consumes hundreds of megabytes of redundant RAM.

1. The Solution: `slots` Attribute Optimization

By defining a class variable tuple named `__slots__` containing pre-declared attribute name strings, Python replaces the dynamic instance dictionary with a compact, fixed-size C array in memory!

RAM Savings with `__slots__`: Using __slots__ reduces object memory overhead by **60% to 70%** and increases attribute access speed! However, instances can no longer accept arbitrary new attributes not explicitly declared inside __slots__.

SLOTS_MEMORY_BENCHMARK.PY

import sys

# Standard Class storing attributes in dynamic __dict__
class StandardMetricRecord:
    def __init__(self, metric_id: str, value: float, status: str):
        self.metric_id = metric_id
        self.value = value
        self.status = status


# Optimized Class using __slots__ fixed C-array allocation
class OptimizedMetricRecord:
    __slots__ = ("metric_id", "value", "status")  # Pre-declared fixed attributes

    def __init__(self, metric_id: str, value: float, status: str):
        self.metric_id = metric_id
        self.value = value
        self.status = status


std_obj = StandardMetricRecord("M_101", 99.5, "OK")
opt_obj = OptimizedMetricRecord("M_101", 99.5, "OK")

# Calculating total memory (Instance size + internal dictionary size)
std_total_bytes = sys.getsizeof(std_obj) + sys.getsizeof(std_obj.__dict__)
opt_total_bytes = sys.getsizeof(opt_obj)  # Has NO __dict__!

print("=== __slots__ RAM Benchmark Comparison ===")
print(f"Standard Class Instance Size (__dict__) : {std_total_bytes} bytes")
print(f"Optimized Class Instance Size (__slots__): {opt_total_bytes} bytes")
print(f"Memory Reduction Efficiency             : ~{(1.0 - (opt_total_bytes / std_total_bytes))*100:.1f}% RAM Saved per Object!")

OUTPUT

=== __slots__ RAM Benchmark Comparison ===
Standard Class Instance Size (__dict__) : 152 bytes
Optimized Class Instance Size (__slots__): 56 bytes
Memory Reduction Efficiency             : ~63.2% RAM Saved per Object!

6. Combining Security & Performance Audits with `match-case`

Integrating security static analysis indicators and performance profiling statistics with Python 3.10+ Structural Pattern Matching (`match-case`) enables building real-time system monitoring dispatchers.

MATCH_CASE_SECURITY_PERF_DISPATCHER.PY

def evaluate_system_health_telemetry(metric_payload: tuple) -> str:
    """
    Routes security and performance diagnostic metric tuples using Structural Pattern Matching.
    Demonstrates processing system health alerts dynamically.
    """
    match metric_payload:
        case ("SECURITY_ALERT", "SUBPROCESS_SHELL_TRUE", str(file_path), int(line)):
            return f"CRITICAL_SECURITY_BLOCKER: Command Injection risk (shell=True) in '{file_path}' at line {line}!"

        case ("SECURITY_ALERT", "INSECURE_PICKLE_LOAD", str(file_path), _):
            return f"CRITICAL_SECURITY_BLOCKER: Arbitrary code execution risk (pickle.load) in '{file_path}'!"

        case ("PERFORMANCE_METRIC", str(func_name), float(latency_s)) if latency_s >= 1.0:
            return f"LATENCY_BREACH_ALERT: Function '{func_name}' execution took {latency_s:.2f}s (Exceeded 1.0s SLA threshold)!"

        case ("MEMORY_METRIC", str(component), float(ram_mb)) if ram_mb >= 500.0:
            return f"MEMORY_LEAK_ALERT: Component '{component}' RAM footprint exceeds {ram_mb:.1f} MB limit!"

        case ("PERFORMANCE_METRIC" | "MEMORY_METRIC", _, _):
            return "SYSTEM_METRIC_PASS: System operates within normal operational parameters."

        case _:
            return "UNKNOWN_TELEMETRY_SCHEMA: Unrecognized metric event."

# Testing Diagnostic Dispatcher
print(evaluate_system_health_telemetry(("SECURITY_ALERT", "SUBPROCESS_SHELL_TRUE", "src/legacy_cli.py", 42)))
print(evaluate_system_health_telemetry(("PERFORMANCE_METRIC", "expensive_db_query", 2.45)))
print(evaluate_system_health_telemetry(("MEMORY_METRIC", "DataCacheEngine", 680.0)))
print(evaluate_system_health_telemetry(("PERFORMANCE_METRIC", "light_helper", 0.02)))

OUTPUT

CRITICAL_SECURITY_BLOCKER: Command Injection risk (shell=True) in 'src/legacy_cli.py' at line 42!
LATENCY_BREACH_ALERT: Function 'expensive_db_query' execution took 2.45s (Exceeded 1.0s SLA threshold)!
MEMORY_LEAK_ALERT: Component 'DataCacheEngine' RAM footprint exceeds 680.0 MB limit!
SYSTEM_METRIC_PASS: System operates within normal operational parameters.

7. Frequently Asked Interview Questions with Answers

Q1: What is Command Injection, and how do you prevent it in Python's `subprocess` module?

Answer: Command Injection occurs when raw user input strings are passed directly into a shell interpreter, allowing malicious users to execute unauthorized OS shell commands using delimiters (like ; or |). It is prevented by passing arguments as an explicit sequence list (e.g., ["ping", "-c", "1", clean_host]) with shell=False (the default) and validating input strings strictly.

Q2: Why is unpickling data from untrusted network sources considered a critical security vulnerability?

Answer: Python's pickle module allows serializing arbitrary Python objects. When deserializing byte streams via pickle.load(), objects defining a custom __reduce__() dunder method can trigger arbitrary shell code execution automatically upon unpickling, allowing full server compromise.

Q3: How does defining `__slots__` inside a class reduce RAM consumption?

Answer: By default, class instances store attributes in a dynamic dictionary (__dict__), which carries hash table overhead. Declaring __slots__ = ("attr1", "attr2") eliminates the __dict__ dynamic dictionary completely, storing attributes in a compact, fixed-size C array in memory and reducing per-instance RAM usage by 60% to 70%.

Q4: How do `cProfile` and `tracemalloc` assist in application optimization?

Answer: cProfile is a deterministic profiler that measures CPU call counts and cumulative execution times per function to pinpoint execution bottlenecks. tracemalloc tracks memory allocation blocks on the Python heap over time to detect memory leaks and measure memory differentials.

Q5: Why should API keys and database credentials be loaded from environment variables rather than hardcoded in source code?

Answer: Hardcoding secrets in source code risks exposing sensitive production credentials in public Git repositories. Reading secrets from host environment variables or .env files via os.environ keeps credentials isolated from the application source code tree.

8. Homework & Practical Assignments

Task 1: Memory Benchmark Task for `slots` Optimization

Create a script named slots_benchmark_task.py inside your lesson_52 folder:

Define a standard class UnoptimizedUser(user_id, email, age) and a slots-optimized class OptimizedUser(user_id, email, age) using __slots__.
Instantiate 10,000 objects of both classes in separate lists.
Use sys.getsizeof() to compute and display the memory size of individual instances and the total memory consumed by both object lists using f-strings.

Task 2: Pattern-Matched Security Audit Engine

Create a script named security_audit_task.py:

Define function audit_code_vulnerability(finding: tuple) -> str parsing finding tuples.
Write a match-case dispatcher:
- case ("EVAL_USE", file, line) → Return "CRITICAL: Banned eval() execution detected!".
- case ("SHELL_TRUE", file, line) → Return "HIGH: Subprocess shell=True vulnerability detected!".
- case ("HARDCODED_KEY", file, line) → Return "HIGH: Hardcoded secret key string detected!".
- case _ → Return "PASS: No critical vulnerabilities found.".
Execute function across sample finding tuples and print outputs.

Task 3: Master Review Capstone Project — Production Enterprise Hardened Security & Performance Audit OS (`security_perf_audit_os.py`)

Create a script named security_perf_audit_os.py inside your lesson_52 folder. This assignment tests and integrates **ALL concepts learned across Lessons 1 through 52**.

Project Architectural Requirements Specification:

Security, Performance & Memory Architecture (Lesson 52):
- Incorporate secure subprocess argument lists with shell=False and input sanitization.
- Read system secrets dynamically from environment variables using os.environ.
- Use __slots__ across core domain classes for memory optimization.
- Incorporate programmatic performance profiling using cProfile and memory tracking via tracemalloc.
Packaging & Distribution Integration (Lesson 51):
- Include a programmatically generated pyproject.toml package specification string and an argparse CLI entry point structure.
Clean Code, Documentation & Refactoring (Lesson 50):
- Apply SOLID principles, DRY, and Google Style Docstrings across all functions and classes.
Testing & Quality Assurance (Lessons 47-48):
- Include unit tests verified via pytest fixtures and unittest.mock.
Asyncio & Concurrency Integration (Lessons 45-46):
- Incorporate asynchronous execution loops and TaskGroups for parallel service audits.
Temporal & RegEx Text Processing (Lessons 43-44):
- Parse UTC-aware timestamps using datetime and zoneinfo.ZoneInfo.
- Pre-compile RegEx patterns with Named Groups for parsing security audit logs.
Type Hints, Generics & Static Safety (Lesson 42):
- Apply explicit modern type annotations (X | Y, list[str], dict[str, Any]) throughout all functions and classes.
Metaprogramming, Closures & Decorators (Lessons 40-41):
- Build function factories and 3-level configurable decorators with @functools.wraps.
Iterators & Generators (Lesson 39):
- Implement generator functions streaming codebase audit lines lazily with $O(1)$ memory.
Full OOP Architecture (Lessons 32-38):
- Define abstract base class BaseHardenedService(ABC) and concrete Data Classes SecurityFinding and PerformanceMetric.
- Build composite manager SecurityPerfAuditOS composing storage drivers and custom context managers.
Observability & Fault Tolerance (Lessons 29-31):
- Set up multi-handler logging to console and hardened_audit.log file.
- Incorporate developer assertions (assert) verifying invariant bounds.
- Define custom exception hierarchy (HardenedAuditError, SecurityVulnerabilityError).
Context Managers & Persistence Layer (Lessons 27-30):
- Use custom class-based context manager HardenedVaultLock to manage database lock files.
- Persist JSON records to hardened_db.json and export CSV audit reports to security_perf_audit.csv using pathlib.Path.
Nested Collections & Comprehensions (Lessons 21-26):
- Maintain in-memory registry dictionaries mapping IDs to Data Class Instances.
- Use List and Dictionary Comprehensions to clean and transform records.
Advanced Function Parameters & Scope (Lessons 15-17):
- Structure logic into pure modular functions with type hints, docstrings, early return Guard Clauses, and *args / **kwargs logging.
Indefinite & Definite Loops (Lessons 13-14):
- Run the interactive CLI interface inside a continuous while True menu loop.
- Iterate through output reports using for loops with enumerate() and .items().
Pattern Matching CLI Dispatcher (Lesson 12):
- Process user CLI command tokens inside a match-case block with hardened match guards:
  - case ["AUDIT", "SECURITY", filepath] → Analyze target file lines for security vulnerabilities.
  - case ["PROFILE", "PERF"] → Execute cProfile benchmark pass.
  - case ["TRACK", "MEMORY"] → Take tracemalloc memory snapshot differential.
  - case ["EXPORT", "CSV"] → Export completed audit metrics to CSV.
  - case ["EXIT" | "QUIT"] → Terminate session safely using a sentinel flag.
  - case _ → Output command error message.
Conditionals, Formatting & Foundations (Lessons 1-11):
- Sanitize all inputs using .strip() and .upper().
- Format tabular reports using f-strings with field width alignment specifiers (:<15, :>10) and clear visual borders.

9. File & Workspace Directory Structure

Standard Course Workspace Layout:

Ensure all exercise files are stored inside their corresponding lesson directories:

python_mastery_course/
│
├── lesson_01/ ... lesson_51/
│
└── lesson_52/
    ├── secure_secrets_demo.py
    ├── cprofile_performance_demo.py
    ├── tracemalloc_memory_demo.py
    ├── slots_benchmark_demo.py
    ├── match_case_security_perf_dispatcher.py
    ├── slots_benchmark_task.py          <-- (Task 1)
    ├── security_audit_task.py           <-- (Task 2)
    └── security_perf_audit_os.py        <-- (Task 3: Master Review Capstone)

10. What We Will Learn Next

Next Up: Lesson 53 — SQLite and Relational Databases

Congratulations on completing Lesson 52! Now that you master security hardening, performance profiling, and memory optimization, we enter Module 9: Database Persistence and ORMs!

In the next lesson, we will cover:

Introduction to Relational Databases and SQL (Structured Query Language).
Working with Python's standard `sqlite3` module.
Creating tables, inserting records, and executing query joins (`CREATE TABLE`, `INSERT`, `SELECT`, `WHERE`).
Preventing SQL Injection vulnerabilities using Parameterized Queries (`?` placeholders).
Managing Database Transactions and rollbacks (`commit()` vs `rollback()`).
Combining database query record streams with match-case structural pattern matchers.

📝 Live Lesson Practice

HTML/CSS JavaScript Python C++ C PHP

⌨️ Practice Inputs (लाइव इनपुट भरें) (खाली होने पर RED, भरने पर GREEN underline)

💻 Code Editor (Monaco VS Code Engine)

👀 Live Preview

Packaging, CLI Tools and Distribution SQLite and Relational Databases

PYTHON Tutorial

Security, Performance and Memory Basics

1. Introduction to Enterprise System Hardening & Optimization

2. Common Security Vulnerabilities & Defense Mechanics

1. Insecure Dynamic Code Execution (`eval()` and `exec()`)

2. Command Injection Vulnerabilities (`subprocess`)

3. Insecure Deserialization (`pickle` Module)

4. Hardcoded Secret Keys vs Environment Variables (`python-dotenv`)

3. Performance Profiling: Identifying CPU Bottlenecks (`cProfile`)

1. Running `cProfile` from Command Line and Programmatically

4. Memory Footprint Analysis (`tracemalloc` & `sys.getsizeof`)

1. Low-Level Object Sizing: `sys.getsizeof()`

2. Heap Tracking via `tracemalloc`

5. Class Memory Optimization using `slots`

1. The Solution: `slots` Attribute Optimization

6. Combining Security & Performance Audits with `match-case`

7. Frequently Asked Interview Questions with Answers

8. Homework & Practical Assignments

Task 1: Memory Benchmark Task for `slots` Optimization

Task 2: Pattern-Matched Security Audit Engine

Task 3: Master Review Capstone Project — Production Enterprise Hardened Security & Performance Audit OS (`security_perf_audit_os.py`)

Project Architectural Requirements Specification:

9. File & Workspace Directory Structure

Standard Course Workspace Layout:

10. What We Will Learn Next

Next Up: Lesson 53 — SQLite and Relational Databases

📝 Live Lesson Practice

OnlineCBT

Useful Link

Important Pages

Courses & Practice

Contact

Share

PYTHON Tutorial

Security, Performance and Memory Basics

1. Introduction to Enterprise System Hardening & Optimization

2. Common Security Vulnerabilities & Defense Mechanics

1. Insecure Dynamic Code Execution (`eval()` and `exec()`)

2. Command Injection Vulnerabilities (`subprocess`)

3. Insecure Deserialization (`pickle` Module)

4. Hardcoded Secret Keys vs Environment Variables (`python-dotenv`)

3. Performance Profiling: Identifying CPU Bottlenecks (`cProfile`)

1. Running `cProfile` from Command Line and Programmatically

4. Memory Footprint Analysis (`tracemalloc` & `sys.getsizeof`)

1. Low-Level Object Sizing: `sys.getsizeof()`

2. Heap Tracking via `tracemalloc`

5. Class Memory Optimization using `__slots__`

1. The Solution: `__slots__` Attribute Optimization

6. Combining Security & Performance Audits with `match-case`

7. Frequently Asked Interview Questions with Answers

8. Homework & Practical Assignments

Task 1: Memory Benchmark Task for `__slots__` Optimization

Task 2: Pattern-Matched Security Audit Engine

Task 3: Master Review Capstone Project — Production Enterprise Hardened Security & Performance Audit OS (`security_perf_audit_os.py`)

Project Architectural Requirements Specification:

9. File & Workspace Directory Structure

Standard Course Workspace Layout:

10. What We Will Learn Next

Next Up: Lesson 53 — SQLite and Relational Databases

📝 Live Lesson Practice

OnlineCBT

Useful Link

Important Pages

Courses & Practice

Contact

Share

5. Class Memory Optimization using `slots`

1. The Solution: `slots` Attribute Optimization

Task 1: Memory Benchmark Task for `slots` Optimization