PHP.CodeCompared.To/Python

There is no <?php opening tag, no $ on variables, and no trailing semicolon. Python's print() is a function that adds a newline for you, so you do not append \n the way you would with echo.

Both languages are interpreted and need no compile step. The biggest visual difference is that a Python file is all code — there is no <?php ... ?> island inside text, because Python is not a templating language. Comments use #, which PHP also accepts.

Python has no curly braces. A colon opens a block and indentation (four spaces by convention) defines its body — the layout you would write anyway in PHP is the actual syntax here. Mixing tabs and spaces is an error, so pick one.

Python has just one comment marker, #. There is no block-comment syntax; instead a string literal as the first statement of a function, class, or module is its docstring, readable at runtime via __doc__ and by tooling — a step beyond PHP's docblocks, which are only comments.

Variables carry no $ sigil — they look like bare words. The booleans are capitalised (True / False) and the empty value is None, of which there is exactly one (PHP's null has the same role). Assignment creates the variable; there is no declaration keyword.

Python's type() returns the class object; type(x).__name__ gives a readable name like PHP's get_debug_type(). Use isinstance() rather than comparing types directly, because it also accepts subclasses — the counterpart to PHP's instanceof.

Both languages bolt gradual typing onto a dynamic core, but with a key difference: PHP's type declarations are enforced at runtime and can raise a TypeError, whereas Python's annotations are not checked at runtime at all — they are hints for tools like mypy and your editor. A wrong type passes silently unless a checker catches it.

In Python / always produces a float (so 4 / 2 is 2.0), and // is integer floor division — the reverse of PHP, where / can yield an int. Python integers are arbitrary precision: there is no PHP_INT_MAX ceiling and no silent promotion to float on overflow.

Empty collections ([], {}) are falsy in both languages. The notable trap for a PHP developer: the string "0" is truthy in Python but falsy in PHP. Python falsy values are None, False, zero, and every empty container — and nothing else.

Python's f-strings are the everyday tool, and like PHP they embed expressions directly: f"{name}". The big difference is concatenation — Python's + will not coerce a number to a string, so you must call str(age) explicitly, unlike PHP's . operator which converts automatically.

Python folds formatting directly into f-strings with a : mini-language: {price:,.2f} means thousands separators and two decimals. It covers the same ground as sprintf / printf but inline at the interpolation site rather than in a separate format string.

Strings are objects with methods in Python, so you chain text.strip().upper() instead of nesting strtoupper(trim($text)). Substring testing is the readable "ell" in "Hello" rather than str_contains, and the same in works for lists and dicts too.

The pair is split / join rather than explode / implode. Note that join is a string method called on the separator ("-".join(parts)), which surprises most newcomers — the separator, not the list, owns the operation.

Python's slice syntax text[start:stop:step] replaces substr and a pile of other helpers. Negative indices count from the end (text[-2:]), and a step of -1 reverses — there is no separate strrev. The same slicing works on lists.

This is the central difference. PHP's single ordered-map array fills every role; Python splits it into list (ordered, mutable), dict (key-value), tuple (immutable sequence), and set (unique, unordered). Choosing the right one is part of writing idiomatic Python.

Lists are objects, so you call numbers.append(4) and numbers.sort() as methods rather than passing the array to array_push / sort. Length is the universal len() function, and membership is the same in keyword used for strings — no in_array.

Key existence is "name" in person (the in keyword again, replacing isset), and the safe lookup with a default is person.get(key, default) — the counterpart to PHP's ??. Iterating key/value pairs uses .items() rather than foreach ... as $key => $value.

Tuples are immutable sequences with no direct PHP equivalent — use them for fixed-size groupings like a coordinate or a returned pair. Unpacking (x, y = point) generalises PHP's array destructuring and makes the swap idiom x, y = y, x read naturally without a temporary.

Python has a real set type with operator algebra: & for intersection, | for union, - for difference. PHP has no set, so the usual workaround is to abuse array keys with array_flip and the array_*_key functions — sets make this both clearer and faster.

Python prefers comprehensions over array_map / array_filter — a single readable expression replaces both. Note array_filter preserves PHP keys (hence the array_values reindex), whereas a Python comprehension always returns a fresh, contiguous list.

The keyword is elif, not elseif or else if. Conditions need no parentheses, and the chaining comparison 80 <= score < 90 is valid Python — a small expressiveness win PHP lacks.

Python's conditional expression reads in value-first order: VALUE if CONDITION else OTHER. There is no dedicated ?? operator; for a default-when-falsy the idiom is name or "anonymous" (note this also fires on empty strings and zero, so it is closer to PHP's ?: than to ??).

Python has no C-style three-part for loop; you iterate over a sequence, and counting comes from range(3) which yields 0, 1, 2. The foreach-over-values form maps directly to for letter in [...].

When you need both the position and the value of a list, wrap it in enumerate() rather than maintaining a counter. It is the direct equivalent of PHP's foreach ($fruits as $index => $fruit) for a plain list, and you can pass start=1 to begin at one.

To walk two (or more) lists in lockstep, zip() pairs them element by element, so you never index a second array by a shared counter. It stops at the shortest input, which is usually what you want.

The list comprehension is Python's signature feature and has no PHP equivalent. It collapses the build-an-empty-array-then-loop pattern into one expression. Note range(1, 6) is half-open — it stops before 6, unlike PHP's inclusive range(1, 5).

The same comprehension syntax builds dicts ({key: value for ...}) and sets ({value for ...}), not just lists. This single, uniform construct replaces a whole family of PHP array-building loops and keeps the transformation logic in one place.

Both languages have lazy generators via yield, and they behave almost identically. Python adds a parenthesised generator expression — like a list comprehension but lazy — which is ideal for feeding sum(), max(), or any() without building an intermediate list.

The keyword is def instead of function, the return type follows a -> arrow, and there are no braces. Functions defined at module level are global by default — there is no $ scoping subtlety, but see the gotcha about reassigning globals.

Default parameters work the same way, and Python's keyword arguments are the model PHP 8's named arguments were based on. One sharp difference: a default value is evaluated once at definition time, so a mutable default like [] is shared across calls — see the gotchas section.

Python uses *numbers to collect positional arguments into a tuple (PHP's ...$numbers) and the same * to spread a list at the call site. The extra trick is **, which collects or spreads keyword arguments through a dict — PHP has no direct equivalent.

Python's lambda is the counterpart to PHP's arrow function fn() =>, and both capture surrounding variables automatically (no PHP use (...) clause needed). A lambda is limited to a single expression; for anything longer, define a named function with def.

Returning several values is idiomatic: a comma-separated return builds a tuple, which the caller unpacks. It is the same shape as PHP's "return an array, then destructure", but reads more directly because the packing and unpacking are implicit.

The constructor is the dunder method __init__, and crucially self is an explicit first parameter of every method — Python never hides the receiver the way PHP's implicit $this does. Instantiation has no new keyword; you call the class like a function.

Member access uses a dot (counter.count), not ->. Attributes are created by assigning to self.something inside __init__ rather than declared in a property list. There is no ++ operator, so increment is self.count += 1.

A subclass lists its parent in parentheses: class Dog(Animal). There is no extends keyword, and overriding a method needs no annotation. To call the parent's version you use super().method(), much like PHP's parent::method().

The @dataclass decorator generates __init__, a readable __repr__, and equality from the annotated fields — close to PHP's constructor property promotion but with more for free. Passing frozen=True makes instances immutable, the rough counterpart to PHP 8.1's readonly properties.

Static methods are marked with the @staticmethod decorator and accessed with a plain dot (MathUtil.square(5)) — there is no :: scope-resolution operator. A variable assigned directly in the class body, like pi, is a shared class attribute.

Python's "dunder" methods are the analogue of PHP's magic methods: __str__ mirrors __toString, __init__ mirrors __construct. Python goes further by letting you overload operators — defining __add__ makes + work on your objects, which PHP does not allow.

Both languages spell the keyword match, but they differ in nature: PHP's match is an expression that returns a value and compares with ===, while Python's match is a statement for structural pattern matching. The case _ wildcard is Python's default, and if guards refine each case.

This is where Python's match outclasses PHP's: it destructures as it matches, binding y from the dict in the same line that tests the shape. PHP's match only compares scalar values, so equivalent logic falls back to nested if checks.

Python enums subclass Enum, and a backed value is given by assignment (HEARTS = "hearts") — read back with .value, exactly like PHP 8.1's backed enums. Methods work the same way, and members compare by identity with is.

The keyword is except, not catch, and the bound variable comes after as. Printing the exception object directly gives its message, so there is no getMessage(). The finally clause behaves identically to PHP's.

You raise rather than throw, and Python ships a rich tree of built-in exception types — ValueError, KeyError, TypeError — that you reach for before writing your own. Custom exceptions subclass Exception, the parallel of extending PHP's Exception.

The with statement and its context managers are Python's preferred cleanup mechanism, replacing the manual try ... finally fclose() dance. On leaving the block the resource is released automatically, even on an exception — most notably with open(path) as file: for files.

Python loads code with import rather than require, and almost everything beyond the core builtins lives in a module you import first — even math. The from module import name form pulls a single name into scope, similar to a PHP use statement for a namespaced symbol.

Every .py file is a module — its filename is the module name, with no namespace declaration needed. Importing geometry runs that file once and exposes its names under geometry.. This example spans two files, so it cannot run inline here.

The if __name__ == "__main__": idiom is everywhere in Python. A module's __name__ is "__main__" only when run directly, and its own name when imported — so this block lets a file act as both an importable library and a runnable script, like the PHP CLI-entry check.

PyPI is Python's Packagist and pip is its Composer. The big mindset shift is the virtual environment: rather than a per-project vendor/ directory, Python isolates dependencies in a venv you activate, keeping each project's packages separate from the system interpreter.

The verbs are json.dumps (dump-string) to encode and json.loads (load-string) to decode — the s suffix distinguishes the string forms from dump / load, which work on file objects. Decoding gives a plain dict, so there is no associative-vs-object flag like PHP's second argument.

Python sorts by a key function — key=lambda person: person["age"] extracts the value to compare — rather than a two-argument comparator with the spaceship operator. This is both faster and clearer for the common "sort by one field" case. Use sorted(people, ...) for a new list instead of sorting in place.

The collections module is a highlight of Python's standard library. Counter tallies items (like array_count_values) and adds .most_common() for free; defaultdict and deque live there too. Reaching for these specialised containers is very idiomatic.

Python's datetime module models date arithmetic with timedelta objects you literally add: today + timedelta(weeks=1). It is more explicit than PHP's string-based modify("+1 week"), and .isoformat() gives the standard YYYY-MM-DD rendering without a format string.

This is the most infamous Python trap for newcomers. A default argument is evaluated a single time at function definition, so a mutable default like into=[] persists and accumulates across calls. The fix is the universal idiom: default to None and create the real value inside the function.

Python has no loose ==: it compares by value without type juggling, so "1" == 1 is simply False and you never need PHP's ===. The separate is operator checks object identity, not equality — reserve it for x is None, never for comparing numbers or strings.

Both languages require a global declaration to reassign a module-level variable from inside a function — a rare point of close agreement. The subtlety: in Python you can read a global without declaring it, and you can mutate a global list or dict in place; only rebinding the name needs global.

A crucial reversal: PHP arrays are value types, so $copy = $original duplicates the data, whereas Python lists and dicts are references, so alias = original makes two names for one object. To actually copy, call .copy(), slice with [:], or use copy.deepcopy() for nested structures.

PHP normalises array keys, folding the string "1" and the integer 1 into one entry. Python keeps key types distinct, so "1" and 1 are two different dict keys. Any dict key must also be hashable (immutable) — a list cannot be a key, but a tuple can.