JavaScript.CodeCompared.To/Python

Python's print() is the equivalent of console.log() — both append a trailing newline. Python statements end at the newline, with no semicolons and no braces; indentation defines structure.

Python f-strings (f"...") interpolate with {...}, the counterpart to JavaScript template literals. Like console.log(), Python's print() separates multiple arguments with spaces.

Python uses # for single-line comments and has no dedicated block-comment syntax — a triple-quoted string serves that role and doubles as a documentation string when placed at the top of a function or module.

Python has no declaration keyword — assignment both creates and binds a variable, so there is no let or const. The idiomatic naming convention is snake_case rather than JavaScript's camelCase.

Python has no real const — an all-caps name is only a convention signalling "do not reassign," and nothing in the language enforces it, unlike JavaScript's const.

Both languages are dynamically typed. Python's type() built-in returns the class object (e.g. <class 'int'>), where JavaScript's typeof returns a string.

Python collapses JavaScript's two empty values (null and undefined) into a single None. The idiomatic test is is None, using identity rather than ==.

Python's tuple unpacking needs no brackets: first, second = 1, 2. The swap idiom a, b = b, a is the direct counterpart to JavaScript's array-destructuring swap.

Python f-strings embed expressions in {...}, just as JavaScript template literals use ${...}. The f prefix is required — a plain string does not interpolate.

Both concatenate with +. For repetition Python overloads the * operator ("-" * 5), which is more concise than JavaScript's repeat() method.

Python spells these upper() and lower() rather than toUpperCase()/toLowerCase(). Note that Python's replace() replaces all occurrences by default, whereas JavaScript's string replace() changes only the first.

Python uses bracket slice syntax word[start:end] instead of a slice() method, and it supports a third "step" value (word[::2]) that JavaScript has no direct equivalent for.

A famous gotcha: Python's join() is called on the separator ("-".join(parts)), not on the list, which is the reverse of JavaScript's parts.join("-").

Python's triple-quoted strings ("""...""") span multiple lines, serving the same purpose as JavaScript's backtick template literals.

Python distinguishes true division (/, always a float) from floor division (//, integer result), so you write 7 // 2 instead of Math.floor(7 / 2). Python also has a real integer type, unlike JavaScript's single number type.

The ** exponentiation operator is identical in both languages. Python integers have unlimited precision, so 2 ** 1000 computes exactly rather than overflowing.

Python converts with the int() and float() built-ins. Unlike JavaScript's parseInt(), which stops at the first non-digit, Python's int("42abc") raises a ValueError — conversion is strict.

Python's math functions live in the math module, which you must import, rather than on a global object like JavaScript's Math.

Python's format mini-language packs grouping and precision into a compact spec ({amount:,.2f}), far terser than JavaScript's toLocaleString() options object.

Python lists support negative indexing, so the last element is simply fruits[-1]. Length comes from the len() built-in rather than a .length property.

Python uses append() where JavaScript uses push(), and insert(0, value) where JavaScript uses unshift(). pop() exists in both.

List slicing is built into Python's bracket syntax, including a step value: nums[::2] takes every other element, which in JavaScript requires a filter() on the index.

The idiomatic Python equivalent of .map() is a list comprehension: [expr for item in iterable]. There is also a map() built-in, but comprehensions are more common and readable.

A comprehension's trailing if clause does the work of .filter(). Generating a range is cleaner than in JavaScript: range(10) yields 0 through 9.

For the common case of summing, Python offers a built-in sum(). The general fold lives in functools.reduce(), the counterpart to JavaScript's .reduce().

Python's sorted() returns a new list and takes a key function instead of a comparator. Crucially, it sorts numbers numerically by default — no comparator needed — avoiding JavaScript's lexicographic-sort surprise.

Python's starred expressions (*rest, [*a, *b]) mirror JavaScript's spread and rest syntax for both unpacking and combining sequences.

Python sets have literal syntax ({1, 2, 3}) and operator overloads for intersection (&) and union (|), which JavaScript's Set lacks — there you fall back to filter and spread.

Python dictionaries use quoted string keys and bracket access (person["name"]) — there is no dot-notation access. dict.get(key, default) supplies a fallback, the role JavaScript's ?? plays.

Assigning to a missing key creates it in both languages. Python always uses bracket syntax for dictionary keys, even when the key is a simple identifier.

Python's dict.items() yields key/value pairs directly, so you do not need an Object.entries() wrapper. Tuple unpacking in the loop header reads naturally.

Python's dict.keys() and dict.values() return lazy view objects; wrap them in list() to materialize them, whereas JavaScript's Object.keys()/Object.values() already return arrays.

The in operator checks dictionary keys in Python, just as it checks object keys in JavaScript. Unlike JavaScript, Python's in on a list checks for a value, which is usually what you want.

Python's double-star unpacking ({**a, **b}) merges dictionaries exactly like JavaScript's object spread, with later keys winning.

Python dictionary keys can be any hashable value, including tuples — so a coordinate pair works directly as a key. In JavaScript you would reach for a Map and contend with identity comparison for object keys.

Python drops the parentheses and braces, using a colon and indentation instead, and spells the chained branch elif rather than else if.

Python's conditional expression reads in English order — a if condition else b — rather than JavaScript's C-style condition ? a : b.

A welcome difference: an empty list, dict, string, or set is falsy in Python, so if not items: tests emptiness directly — no .length check needed. In JavaScript an empty [] is truthy, which trips up newcomers.

Python has a single == that compares by value without JavaScript's string-to-number coercion, so "1" == 1 is False. There is no === because none is needed; use is only for identity (such as is None).

Python lets you chain comparisons mathematically: 1 < x < 10 means exactly what it looks like, with no need for the && that JavaScript requires.

Python's match (3.10+) is more powerful than JavaScript's switch: each case is self-contained with no fall-through and no break, and it can destructure structures and bind variables. The wildcard case is case _.

Python has no C-style three-part for loop. You iterate over range(3), which produces 0, 1, 2. There is no ++ operator — use index += 1 when you need manual increment.

Python's for x in collection iterates values directly — the equivalent of JavaScript's for...of. There is no values-vs-keys footgun like JavaScript's for...in.

Python's enumerate() yields (index, value) pairs — index first, the reverse of the argument order JavaScript's forEach() callback receives.

The while loop is nearly identical, aside from Python's colon and indentation in place of parentheses and braces.

Both break and continue behave the same. Python additionally supports a for...else clause that runs when the loop finishes without breaking — a feature JavaScript has no equivalent for.

Python defines functions with def and an indented body rather than the function keyword and braces. The return statement works the same way.

Default-argument syntax looks the same, but beware: Python evaluates the default once at definition time, so a mutable default like [] is shared across calls — a classic Python pitfall that JavaScript, which re-evaluates each call, does not have.

Python has true keyword arguments — role="admin" at the call site — so you do not need JavaScript's options-object pattern. The bare * in the signature forces the following parameters to be passed by name.

Python's *numbers collects extra positional arguments into a tuple, the counterpart to JavaScript's rest parameter. The built-in sum() then adds them up directly.

Python's **attributes gathers arbitrary keyword arguments into a dict, so callers pass color="red" directly instead of building an options object as in JavaScript.

Python returns a tuple (the comma makes it one) and unpacks it on assignment, so you rarely build an explicit array. The built-ins min() and max() accept an iterable directly, with no spread needed.

Python's lambda is limited to a single expression — it cannot contain statements — so it is far more restricted than a JavaScript arrow function. For anything multi-line, define a named function with def.

Both support closures, but Python requires the nonlocal keyword to reassign a variable from an enclosing scope. Without it, count += 1 would raise an error, since Python would treat count as a new local.

Python has first-class decorator syntax: @shout above a definition wraps the function and rebinds its name. JavaScript has no built-in equivalent for functions, so you wrap manually with a higher-order function.

Python's constructor is __init__, instances are created without new (just Dog("Rex")), and every method takes an explicit first parameter self — there is no implicit this.

Python declares the base class in parentheses (class Cat(Animal)) rather than with extends. Method overriding works the same way in both.

Python calls the parent initializer explicitly as super().__init__(value). Unlike JavaScript, Python does not force the super call to come before you assign other attributes.

Python marks class-level methods with the @staticmethod decorator rather than a static keyword. Python also offers @classmethod, which receives the class itself as its first argument.

Python's @property decorator makes a method accessible as a bare attribute (circle.area, no parentheses) — the same effect as a JavaScript get accessor.

Python's __str__ dunder method controls how an object converts to a string, the role JavaScript's toString() plays. Python also has __repr__ for an unambiguous developer-facing representation.

Python catches errors with except and can name the specific exception type (ZeroDivisionError) — and unlike JavaScript, dividing by zero genuinely raises an error rather than returning Infinity.

Python uses raise where JavaScript uses throw, and the standard library provides specific exception types like ValueError and TypeError rather than a single generic Error.

The finally block runs whether or not an exception occurred, identically in both languages.

A custom Python exception simply subclasses Exception and often needs nothing more than pass, whereas a JavaScript error class typically must call super(message) and set this.name.

Python's with statement plus a context manager guarantees setup and teardown around a block — used everywhere for files, locks, and transactions. JavaScript has no with for this, so the equivalent is passing a callback.

Both use yield for lazy generators. Python marks a generator simply by using yield anywhere in a normal def — there is no special function* syntax — and materializes it with list().

Python's next() built-in returns the yielded value directly and raises StopIteration when exhausted, whereas JavaScript's .next() returns a { value, done } object.

Both use async/await, but Python's event loop is not implicit: you must start it with asyncio.run(main()), whereas a JavaScript runtime always has one running and you simply call main().

Python's asyncio.gather() awaits multiple coroutines concurrently and returns their results in order — the counterpart to JavaScript's Promise.all().

Python's JSON support lives in the json module (which you import), with json.dumps() and json.loads() matching JavaScript's global JSON.stringify() and JSON.parse().

Python modules need no export — every top-level name is importable, and you pull names in with from module import name. These examples span multiple files, so they cannot run in this single-file runner.