feat: add curated video resource pages for 10 advanced Python concepts

travisjneuman · claude · travisjneuman · commit 39e878288e47 · 2026-02-26T15:16:11.000-05:00
Add video link files for http-explained, api-basics, async-explained,
testing-strategies, generators-and-iterators, collections-deep-dive,
functools-and-itertools, the-terminal-deeper, regex-explained, and
security-basics. Each file contains 3-5 curated YouTube links from
verified educators (Corey Schafer, ArjanCodes, Socratica, freeCodeCamp,
Tech With Tim, mCoding). Completes the video resources coverage across
all 28 concept docs (8 beginner + 10 intermediate + 10 advanced).

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/concepts/videos/api-basics.md b/concepts/videos/api-basics.md
@@ -0,0 +1,21 @@
+# API Basics — Video Resources
+
+[← Back to Concept](../api-basics.md)
+
+## Best Single Video
+
+**[APIs for Beginners - How to Use an API (Full Course)](https://youtube.com/watch?v=GZvSYJDk-us)** by freeCodeCamp / Craig Dennis (~2.5 hrs)
+Why: The definitive beginner API course. Starts with what an API is, how HTTP works, then moves to hands-on practice with Postman and helper libraries in both JavaScript and Python. Includes real-world examples with Spotify and Twilio APIs. Assumes only basic coding knowledge.
+
+## Alternatives
+
+- **[Python Requests Tutorial: Request Web Pages, Download Images, POST Data, Read JSON, and More](https://youtube.com/watch?v=tb8gHvYlCF0)** by Corey Schafer (~25 min) — Focused on the Python side: making GET/POST requests, reading JSON responses, downloading files, and handling authentication. The practical companion to understanding API theory.
+- **[Python FastAPI Tutorial](https://youtube.com/watch?v=-ykeT6kk4bk)** by Tech With Tim (~58 min) — Teaches API concepts from the builder's perspective. Covers endpoints, HTTP methods, path/query parameters, request bodies, and status codes while building a FastAPI app from scratch.
+
+## Deep Dives
+
+- **[Python API Development - Comprehensive Course for Beginners](https://youtube.com/watch?v=0sOvCWFmrtA)** by freeCodeCamp / Sanjeev Thiyagarajan (~19 hrs) — The most comprehensive Python API course available for free. Builds a full API with FastAPI, PostgreSQL, SQLAlchemy, Alembic, pytest, Docker, and CI/CD. Takes you from zero to production-ready.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/async-explained.md b/concepts/videos/async-explained.md
@@ -0,0 +1,22 @@
+# Async Explained — Video Resources
+
+[← Back to Concept](../async-explained.md)
+
+## Best Single Video
+
+**[Python Tutorial: AsyncIO - Complete Guide to Asynchronous Programming](https://youtube.com/watch?v=oAkLSJNr5zY)** by Corey Schafer (~90 min)
+Why: The most thorough free asyncio tutorial available. Uses clear visual animations to show what happens at each step: event loops, coroutines, tasks, futures, and the async/await syntax. Covers create_task, asyncio.gather, TaskGroup, error handling, and refactoring blocking I/O with asyncio.to_thread. Start here for a complete mental model.
+
+## Alternatives
+
+- **[Next-Level Concurrent Programming in Python with Asyncio](https://youtube.com/watch?v=GpqAQxH1Afc)** by ArjanCodes (~25 min) — Picks up where the basics leave off: async generators, async comprehensions, converting blocking code to concurrent code, and how concurrency affects software design. A more architecture-focused perspective.
+- **[Asyncio: Understanding Async / Await in Python](https://youtube.com/watch?v=2IW-ZEui4h4)** by ArjanCodes (~20 min) — A gentler introduction focused on the core async/await pattern. Demonstrates the performance difference between synchronous and asynchronous code with a practical API-calling example.
+
+## Deep Dives
+
+- **[Python Threading Tutorial](https://youtube.com/watch?v=IEEhzQoKtQU)** by Corey Schafer (~16 min) — Covers threading as an alternative concurrency model. Understanding threads helps you appreciate when asyncio is the better choice and when threading makes more sense.
+- **[Python Multiprocessing Tutorial](https://youtube.com/watch?v=fKl2JW_qrso)** by Corey Schafer (~17 min) — Completes the concurrency picture by explaining multiprocessing for CPU-bound tasks. After watching all three (async, threading, multiprocessing), you will understand which tool to reach for in each situation.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/collections-deep-dive.md b/concepts/videos/collections-deep-dive.md
@@ -0,0 +1,21 @@
+# Collections Deep Dive — Video Resources
+
+[← Back to Concept](../collections-deep-dive.md)
+
+## Best Single Video
+
+**[Iterators, Iterables, and Itertools](https://youtube.com/watch?v=WR7mO_jYN9g)** by Socratica (~12 min)
+Why: Socratica covers the collections-adjacent territory of itertools alongside the iterator protocol, showing how Python's data-handling tools connect. High production quality and a methodical pace that helps the concepts sink in. A strong companion to studying the collections module.
+
+## Alternatives
+
+- **[Python Tutorial: Generators - How to Use Them and the Benefits You Receive](https://youtube.com/watch?v=bD05uGo_sVI)** by Corey Schafer (~11 min) — Generators are the gateway to understanding lazy evaluation, which is the design philosophy behind many collections module tools like deque and defaultdict. Covers yield, memory efficiency, and generator expressions.
+- **[Python Tutorial: AsyncIO - Complete Guide to Asynchronous Programming](https://youtube.com/watch?v=oAkLSJNr5zY)** by Corey Schafer (~90 min) — The section on data structures for concurrent programming covers how deque is used as a thread-safe collection and how OrderedDict behavior evolved in modern Python. Watch the data structures section for collections context.
+
+## Deep Dives
+
+- **[Special Methods](https://youtube.com/watch?v=IkWrlRei0uA)** by Socratica (~10 min) — Understanding dunder methods (__getitem__, __len__, __contains__) is essential for knowing how collections types like defaultdict and Counter work under the hood. This video explains the protocol that makes Python collections composable.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/functools-and-itertools.md b/concepts/videos/functools-and-itertools.md
@@ -0,0 +1,22 @@
+# functools and itertools — Video Resources
+
+[← Back to Concept](../functools-and-itertools.md)
+
+## Best Single Video
+
+**[Python Tutorial: Decorators - Dynamically Alter The Functionality Of Your Functions](https://youtube.com/watch?v=FsAPt_9Bf3U)** by Corey Schafer (30 min)
+Why: functools.wraps is the most important functools tool for intermediate developers, and this video teaches it in context. Starts from closures, builds to decorators, and shows functools.wraps in action. Understanding this pattern unlocks the rest of functools.
+
+## Alternatives
+
+- **[The Single Most Useful Decorator in Python](https://youtube.com/watch?v=DnKxKFXB4NQ)** by mCoding (8 min) — A focused deep dive on functools.wraps specifically: why every decorator should use it, what breaks without it, and the subtle metadata issues it solves. Short and immediately actionable.
+- **[Iterators, Iterables, and Itertools](https://youtube.com/watch?v=WR7mO_jYN9g)** by Socratica (~12 min) — Covers the itertools module alongside the iterator protocol. Shows chain, islice, count, cycle, and other itertools functions with clean examples. A solid itertools primer.
+
+## Deep Dives
+
+- **[Python Tutorial: Generators - How to Use Them and the Benefits You Receive](https://youtube.com/watch?v=bD05uGo_sVI)** by Corey Schafer (~11 min) — Generators are the foundation that itertools builds on. Understanding yield and lazy evaluation is prerequisite knowledge for using itertools effectively. This video provides that foundation.
+- **[Python Decorators: The Complete Guide](https://youtube.com/watch?v=QH5fw9kxDQA)** by ArjanCodes (22 min) — Covers both functional and class-based decorators with a software design lens. The sections on functools.wraps and decorators with arguments show functools patterns in a broader architectural context.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/generators-and-iterators.md b/concepts/videos/generators-and-iterators.md
@@ -0,0 +1,21 @@
+# Generators and Iterators — Video Resources
+
+[← Back to Concept](../generators-and-iterators.md)
+
+## Best Single Video
+
+**[Python Tutorial: Generators - How to Use Them and the Benefits You Receive](https://youtube.com/watch?v=bD05uGo_sVI)** by Corey Schafer (~11 min)
+Why: Builds generators from the ground up, starting with a normal function and converting it to a generator with yield. Demonstrates memory savings with concrete before-and-after measurements. Clear, concise, and immediately practical. The go-to starting point for understanding generators.
+
+## Alternatives
+
+- **[Generators](https://youtube.com/watch?v=gMompY5MyPg)** by Socratica (~9 min) — A polished, classroom-style explanation of generators with a focus on the conceptual "why." Socratica's production quality makes this feel like a lecture, which some learners prefer.
+- **[Iterators, Iterables, and Itertools](https://youtube.com/watch?v=WR7mO_jYN9g)** by Socratica (~12 min) — Covers the iterator protocol (__iter__ and __next__), what makes something iterable versus an iterator, and introduces the itertools module. A different angle that focuses on the protocol underneath generators.
+
+## Deep Dives
+
+- **[Python Tutorial: Decorators - Dynamically Alter The Functionality Of Your Functions](https://youtube.com/watch?v=FsAPt_9Bf3U)** by Corey Schafer (30 min) — Understanding closures (covered in the first half) is essential for grasping how generators maintain state between yields. This video fills in the mental model that makes generators click.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/http-explained.md b/concepts/videos/http-explained.md
@@ -0,0 +1,21 @@
+# HTTP Explained — Video Resources
+
+[← Back to Concept](../http-explained.md)
+
+## Best Single Video
+
+**[Python Tutorial: AsyncIO - Complete Guide to Asynchronous Programming](https://youtube.com/watch?v=oAkLSJNr5zY)** by Corey Schafer (~90 min)
+Why: While titled AsyncIO, this video begins with an excellent breakdown of how HTTP requests work, the request-response cycle, and why async matters for web communication. Corey uses animations to show what happens when your Python code talks to a server. The HTTP fundamentals section in the first 20 minutes is one of the clearest explanations available.
+
+## Alternatives
+
+- **[APIs for Beginners - How to Use an API (Full Course)](https://youtube.com/watch?v=GZvSYJDk-us)** by freeCodeCamp / Craig Dennis (~2.5 hrs) — Starts with how the web works, HTTP methods, status codes, headers, and request/response anatomy before building anything. The first 30 minutes are a standalone HTTP primer.
+- **[Python Requests Tutorial: Request Web Pages, Download Images, POST Data, Read JSON, and More](https://youtube.com/watch?v=tb8gHvYlCF0)** by Corey Schafer (~25 min) — Hands-on walkthrough of Python's requests library: GET, POST, headers, JSON responses, and authentication. Covers the practical side of making HTTP calls from Python.
+
+## Deep Dives
+
+- **[Python API Development - Comprehensive Course for Beginners](https://youtube.com/watch?v=0sOvCWFmrtA)** by freeCodeCamp / Sanjeev Thiyagarajan (~19 hrs) — A full course building a REST API with FastAPI. The opening sections cover HTTP methods, status codes, request bodies, and how APIs use HTTP under the hood. Watch the first hour for a thorough HTTP deep dive in a Python context.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/regex-explained.md b/concepts/videos/regex-explained.md
@@ -0,0 +1,21 @@
+# Regex Explained — Video Resources
+
+[← Back to Concept](../regex-explained.md)
+
+## Best Single Video
+
+**[Python Tutorial: re Module - How to Write and Match Regular Expressions (Regex)](https://youtube.com/watch?v=K8L6KVGG-7o)** by Corey Schafer (~53 min)
+Why: The most comprehensive free regex tutorial for Python developers. Covers character classes, quantifiers, groups, lookaheads, and practical patterns for matching emails, URLs, and phone numbers. Uses Python's re module throughout with live coding and clear explanations of each metacharacter.
+
+## Alternatives
+
+- **[Regular Expressions in Python](https://youtube.com/watch?v=nxjwB8up2gI)** by Socratica (~8 min) — A concise, polished introduction that covers the core regex syntax and Python's re module in under 10 minutes. Ideal if you want the essentials without the deep dive, or as a refresher.
+- **[Regular Expressions (Regex) Tutorial: How to Match Any Pattern of Text](https://youtube.com/watch?v=sa-TUpSx1JA)** by Corey Schafer (~38 min) — A language-agnostic regex tutorial that focuses purely on the pattern syntax. Watch this first if you want to understand regex itself before applying it in Python. Covers character sets, anchors, groups, and alternation.
+
+## Deep Dives
+
+- **[Python Tutorial: Generators - How to Use Them and the Benefits You Receive](https://youtube.com/watch?v=bD05uGo_sVI)** by Corey Schafer (~11 min) — When processing large files with regex, generators let you match patterns lazily without loading everything into memory. Understanding yield is key to writing regex-based parsers that scale.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/security-basics.md b/concepts/videos/security-basics.md
@@ -0,0 +1,22 @@
+# Security Basics — Video Resources
+
+[← Back to Concept](../security-basics.md)
+
+## Best Single Video
+
+**[Python Tutorial: Securely Manage Passwords and API Keys with DotEnv](https://youtube.com/watch?v=PYuTzLswn_Y)** by Corey Schafer (~10 min)
+Why: The single most common security mistake beginners make is hardcoding secrets in source code. This video covers environment variables, .env files, python-dotenv, and gitignore patterns to keep credentials out of your repository. Short, practical, and immediately applicable to every Python project.
+
+## Alternatives
+
+- **[Cryptography for Beginners: Full Python Course (SHA-256, AES, RSA, Passwords)](https://youtube.com/watch?v=j6vNTilCEZo)** by freeCodeCamp / Thanishkka (~1 hr) — A hands-on course building a command-line cryptography tool in Python. Covers hashing with SHA-256, symmetric encryption with AES, asymmetric encryption with RSA, and secure password handling. Teaches the theory alongside working code.
+- **[Python Tutorial: AsyncIO - Complete Guide to Asynchronous Programming](https://youtube.com/watch?v=oAkLSJNr5zY)** by Corey Schafer (~90 min) — The sections on error handling and safe task cancellation teach defensive programming patterns that are fundamental to security. Understanding how to handle exceptions properly prevents information leakage and denial-of-service vulnerabilities.
+
+## Deep Dives
+
+- **[Python API Development - Comprehensive Course for Beginners](https://youtube.com/watch?v=0sOvCWFmrtA)** by freeCodeCamp / Sanjeev Thiyagarajan (~19 hrs) — Includes substantial sections on password hashing with bcrypt, JWT authentication, input validation with Pydantic, SQL injection prevention with SQLAlchemy, and environment-based configuration. The authentication and authorization chapters (around hours 5-8) are a practical security masterclass.
+- **[Python Tutorial: Unit Testing Your Code with the unittest Module](https://youtube.com/watch?v=6tNS--WetLI)** by Corey Schafer (~39 min) — Testing is a security practice. This video teaches you to write tests that verify your validation logic, authentication flows, and error handling work correctly, catching security regressions before they reach production.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/testing-strategies.md b/concepts/videos/testing-strategies.md
@@ -0,0 +1,21 @@
+# Testing Strategies — Video Resources
+
+[← Back to Concept](../testing-strategies.md)
+
+## Best Single Video
+
+**[How To Write Unit Tests For Existing Python Code (Part 1)](https://youtube.com/watch?v=ULxMQ57engo)** by ArjanCodes (~25 min)
+Why: Shows the real-world challenge of adding tests to code that was not designed for testing. Covers mocking, patching, and writing tests without modifying the original implementation. Practical, not theoretical, and immediately applicable to your own projects.
+
+## Alternatives
+
+- **[Python Tutorial: Unit Testing Your Code with the unittest Module](https://youtube.com/watch?v=6tNS--WetLI)** by Corey Schafer (~39 min) — The classic introduction to Python's built-in unittest module. Covers test structure, assertions, setUp/tearDown, and mocking. A thorough foundation before moving to pytest.
+- **[How To Write Unit Tests For Existing Python Code (Part 2)](https://youtube.com/watch?v=NI5IGAim8XU)** by ArjanCodes (~22 min) — The follow-up that shows how refactoring code to improve testability also improves the overall design. Demonstrates the symbiotic relationship between clean architecture and easy testing.
+
+## Deep Dives
+
+- **[Python API Development - Comprehensive Course for Beginners](https://youtube.com/watch?v=0sOvCWFmrtA)** by freeCodeCamp / Sanjeev Thiyagarajan (~19 hrs) — Includes a substantial section on testing with pytest in a real application context: fixtures, parametrize, database testing, and CI/CD integration. Watch the testing chapters (around hour 14-17) for an advanced, production-oriented approach.
+
+---
+
+*Last verified: February 2026*
diff --git a/concepts/videos/the-terminal-deeper.md b/concepts/videos/the-terminal-deeper.md
@@ -0,0 +1,22 @@
+# The Terminal (Deeper) — Video Resources
+
+[← Back to Concept](../the-terminal-deeper.md)
+
+## Best Single Video
+
+**[Python Tutorial: Calling External Commands Using the Subprocess Module](https://youtube.com/watch?v=2Fp1N6dof0Y)** by Corey Schafer (~19 min)
+Why: Bridges the gap between knowing terminal commands and controlling them from Python. Covers subprocess.run, capturing output, handling errors, piping commands, and shell=True safety considerations. The essential video for Python developers who want to automate terminal workflows.
+
+## Alternatives
+
+- **[Python Tutorial: Pathlib - The Modern Way to Handle File Paths](https://youtube.com/watch?v=yxa-DJuuTBI)** by Corey Schafer (~30 min) — File path manipulation is one of the most common terminal-adjacent tasks in Python. This video covers pathlib, which replaces many os.path operations with a cleaner, object-oriented API. Essential for anyone working with files from Python scripts.
+- **[Python Tutorial: Zip Files - Creating and Extracting Archives](https://youtube.com/watch?v=z0gguhEmWiY)** by Corey Schafer (~10 min) — Covers Python's zipfile module for creating and extracting archives programmatically. A practical terminal skill translated into Python.
+
+## Deep Dives
+
+- **[Python Threading Tutorial](https://youtube.com/watch?v=IEEhzQoKtQU)** by Corey Schafer (~16 min) — When terminal commands take a long time, threading lets you run multiple in parallel. This video explains threading with examples that include running external processes concurrently.
+- **[Python Tutorial: Securely Manage Passwords and API Keys with DotEnv](https://youtube.com/watch?v=PYuTzLswn_Y)** by Corey Schafer (~10 min) — Environment variables are fundamental to terminal-based workflows. This video covers .env files, the python-dotenv package, and secure secrets management, skills every developer needs when working at the command line.
+
+---
+
+*Last verified: February 2026*
