Become an AI Engineer: Python for JavaScript Developers

Setting up the environment is the worst part of learning any new language — so let's make it painless. In this lesson you'll build a modern Python development environment using uv, a single, blazing-fast tool that replaces the entire Node.js toolchain you already know.

You'll install uv, then install and manage Python versions (like nvm), scaffold a new project with uv init (like npm init), and add and remove dependencies with uv add and uv remove (like npm install / uninstall). You'll explore every file uv generates and map it to its Node equivalent: pyproject.toml is your package.json, .python-version is your .nvmrc, and main.py is your index.js. You'll run code the right way with uv run python main.py, which guarantees the correct Python version every time.

Then you'll add Ruff — a single tool that does the job of both ESLint and Prettier — and use ruff check, ruff format, and ruff check --fix to lint and auto-fix your code. You'll even see Python's unlimited-precision integers in action (2 ** 100).

By the end you'll have a clean, professional Python project and a complete mental map from the npm/nvm/ESLint/Prettier workflow to Python's uv + ruff.

Downloads & resources: • uv (installer + docs): https://astral.sh/uv — install: curl -LsSf https://astral.sh/uv/install.sh | sh • Ruff (linter + formatter): https://docs.astral.sh/ruff/ • requests (demo dependency): https://pypi.org/project/requests/ • Attached: Links.md with every command and link

This is the lesson that makes everything else click: Python syntax for JavaScript developers, taught by reimplementing commented JavaScript directly in Python, line by line.

You'll learn how Python declares variables without let, const, or var, why there's only None (no separate null and undefined), and how type() replaces typeof. You'll see Python's strict type coercion — why "5" + 3 raises a TypeError and how to convert values explicitly with str(), int(), and float() — and the truthiness differences that trip up JavaScript developers: in Python, NaN is truthy while empty [] and {} are falsy (the opposite of JS). You'll write f-strings (template literals without the $), use the most common string methods (slicing, upper, replace which replaces all by default, in for includes, * for repeat, ord/chr), and compare operators — there's no ===, and and/or/not are words. Finally you'll master the ternary expression (where the value comes first) and destructuring, which Python calls "unpacking."

By the end you'll have a rock-solid Python-vs-JavaScript syntax map that you'll rely on for the rest of the course.

Learn Python's core data structures by mapping them directly to the JavaScript arrays and objects you already use every day.

You'll start with lists (Python's arrays) and discover the biggest gotcha for JavaScript developers — accessing an out-of-range index raises an IndexError instead of quietly returning undefined. You'll use built-in negative indexing (a[-1]), slicing (a[2:5]), index, and the clean in membership check, and copy a list with [*a]. Then you'll master dictionaries (Python's objects): bracket-only access (no dot notation), why a missing key raises a KeyError, and the safe .get(key, default) method that replaces optional chaining. You'll iterate keys and values with .items() (the Object.entries equivalent) and delete a key with del. Finally you'll meet tuples — immutable lists that JavaScript simply doesn't have — learn why reassigning an item raises an error, and avoid the sneaky single-element trailing-comma trap (a = 1,).

By the end you'll confidently pick the right container for the job and avoid the classic array-and-object-to-list-and-dict mistakes.

Same logic you already know from JavaScript, brand-new Pythonic syntax. This lesson covers Python control flow from end to end.

You'll write if / elif / else (note it's elif, not else if), use the match / case statement that replaces switch (with case _: as the default), and iterate collections directly with for value in items:. You'll use break and continue exactly as in JavaScript, replace forEach((v, i) => …) with enumerate, and — most importantly — learn list comprehensions, Python's elegant and readable equivalent of map and filter (for example, [n*n for n in nums] and [n for n in nums if n % 2 == 0]). You'll also understand why indentation is the syntax in Python — there are no curly braces — and why putting the operation first makes comprehensions read almost like plain English.

By the end you'll read and write idiomatic Python control flow with total confidence.

Learn Python functions the way a JavaScript developer actually thinks about them, from the basics all the way to decorators.

You'll define functions with def (there's no function keyword), return None implicitly, and use pass for empty bodies. You'll gain fine-grained control over arguments with keyword and positional-only parameters using the * and / separators — something JavaScript can't do cleanly. You'll write Python's arrow-function equivalent with lambda, then dive into closures, seeing how inner functions capture outer values and why you need the nonlocal keyword to reassign an enclosing variable (a classic gotcha that raises UnboundLocalError if you forget it). Finally you'll learn decorators — Python's clean, readable @decorator syntax for wrapping a function with another function, replacing the manual higher-order-function pattern you'd write in JavaScript.

By the end you'll write flexible, powerful, reusable Python functions and understand the mechanics behind how they work.

Master object-oriented programming in Python by comparing it directly to the JavaScript classes you already know.

You'll define classes with the same class keyword, write the constructor as __init__, and understand why every method takes an explicit self — Python has no implicit this, so the instance is always passed in. You'll create instances without the new keyword, add regular methods and static methods with @staticmethod, and implement inheritance with class Sub(Base) and super().__init__(...) (note that super() itself takes no arguments). Along the way you'll see exactly how Python's object model differs from JavaScript's, and why passing self everywhere quickly becomes second nature.

By the end you'll design and build clean, Pythonic classes — with constructors, methods, static methods, and inheritance — with real confidence.

Learn how Python organizes code across files and folders, and how its module and package system compares to JavaScript's import/export and Node's modules.

You'll use import module, from module import thing, and import module as alias, and adopt the best practice of importing only what you need. You'll see how packages are built with an __init__.py file — Python's index.js barrel-file equivalent — and how __all__ controls what a wildcard import exposes. You'll learn that relative imports use dots instead of slashes (from .module import x for the same folder, from ..module import y for the parent), and how pyproject.toml acts as your package.json. You'll also understand why Python's "batteries included" standard library means you reach for third-party packages far less often than you do with npm.

By the end you'll structure real Python projects cleanly, work across multiple files, and build shareable packages.

Write safer, more robust Python with proper error handling, mapped straight to JavaScript's try/catch.

You'll learn try / except / finally (Python's version of try/catch/finally), how to raise errors with raise instead of throw, and why you must always name the error type (you can't raise "a string"). You'll catch multiple exception types in the correct order — specific exceptions first, a general except Exception last, so it doesn't accidentally swallow everything — and define your own custom exceptions by subclassing Exception. These are the exact patterns you'll use to make production Python fail gracefully and produce clear, debuggable error messages instead of cryptic crashes.

By the end you'll handle and raise exceptions like a seasoned Python developer.

If you already know Promises and async/await, you'll feel right at home with asynchronous Python — with one crucial twist you need to know.

You'll write async functions and await them just like in JavaScript, and mimic a one-second API call with asyncio.sleep. Then you'll hit the key difference: in Python the event loop does not start automatically. Simply calling your main() only produces the warning "coroutine was never awaited" — you must run it explicitly with asyncio.run(main()). You'll understand coroutines, why Python triggers the event loop manually, and how that differs from JavaScript. Finally you'll make real HTTP requests with the requests library — Python's axios — reading response.status_code and response.json(), and you'll see it also supports POST, PUT, PATCH, and DELETE.

By the end you'll understand Python's async model and be able to call real APIs from your Python code.

Downloads & resources: • requests: https://pypi.org/project/requests/ — install: uv add requests • asyncio (built in): https://docs.python.org/3/library/asyncio.html • Free practice API: https://jsonplaceholder.typicode.com/ • Attached: Links.md