Python.CodeCompared.To/PHP

echo is a language construct rather than a function, so it needs no parentheses and returns nothing — and, unlike print(), it adds no newline, which is why every example here writes "\n" itself. The closing ?> tag is deliberately omitted: a stray blank line after it would be sent to the browser and break a header, so leaving it off is the convention in every modern PHP codebase.

The convenience stops short of Python's: only a bare variable, an array index and a property access interpolate directly, so anything with a method call or arithmetic in it needs the braced form "{$order->total()}". echo accepts a comma-separated list, which is the closest thing to print's several arguments — but it inserts no spaces between them, so you write the spaces yourself.

print_r is the readable dump, closest to print(obj); var_export emits valid PHP source and is the analogue of repr; var_dump is a third form that adds the type and length of every leaf, and is the one you actually reach for when a type is the question. Each takes a flag to return the string instead of echoing it, which is what the bare true in var_export($person, true) is doing.

A Python team lives in the REPL; PHP's interactive shell exists and is used by roughly nobody, because the natural way to run PHP is to point a web server at a directory. php -S ships inside the language and serves a directory over HTTP with no configuration at all, which is the quickest way to watch a PHP file behave the way it will in production.

Python stores the annotation in greet.__annotations__ and otherwise ignores it, so greet(42) is accepted and then fails a line later complaining about + — an error message about the wrong thing, in the wrong place. PHP checks the argument as the call is made and names the parameter, the expected type, and the caller's file and line. Type checking in Python is real and valuable, but it lives in mypy or pyright and runs when you ask it to; a Python program in production has no idea its annotations exist.

declare(strict_types=1) must be the very first statement in the file, and it governs the calls made in that file rather than the functions declared in it — the detail that catches everyone. Every serious PHP codebase turns it on at the top of every file and most frameworks generate it. Python has no equivalent because it has nothing to switch off: double("21") returns the string "2121", which is worse than either PHP mode, and the annotation prevented none of it.

PHP writes ?int as shorthand for int|null, much as Python once wrote Optional[int]. The difference is enforcement again: PHP checks the union at the boundary of every call, so a value that reaches the body genuinely is one of the listed types and the === null test is the only branch needed. In Python the same signature guarantees nothing, and defensive code inside the function is not paranoia.

A typed PHP property also has a third state Python has no word for: uninitialized. Declaring public float $total; with no default leaves the property holding no value at all, and reading it before it is written raises an Error rather than handing back null. That is a genuinely useful guarantee — a half-constructed object cannot quietly leak a null downstream, which is exactly what a Python class with self.total = None in __init__ does.

== in PHP compares after conversion, so "1" == 1 is true; === compares type and value the way Python's == does in these cases, and is what you should write essentially always. PHP 8 tightened the rules a great deal — 0 == "hello" was true before PHP 8 and is false now — but 0 == "" is still true, which is enough of a trap to justify the blanket rule. Python converts only between numeric types (1 == 1.0), the one case the two languages agree on.

PHP's model is called shared-nothing: the interpreter boots, includes your files, produces a response, and tears the entire process state down. That is why PHP needs no application server and no worker restarts on deploy — replacing the file is the deploy — and why a memory leak is nearly impossible to write. It is also why every cache, session and connection pool in PHP lives in an external service (Redis, Memcached, the database) rather than in a module-level dictionary. Modern setups blunt the cost with OPcache, which keeps the compiled bytecode between requests, and with long-running runtimes like Swoole and FrankenPHP — but the default, and the one every library assumes, is the fresh world.

Every modern PHP framework wraps these in a proper request object exactly because ambient global input is untestable and unmockable, so a Laravel or Symfony codebase looks much more like Flask than like this. But the superglobals are still there, still populated, and still what a WordPress plugin or a legacy script will reach for — so recognizing them matters even when you never write them. $_SESSION is the odd one out: it survives between requests, because it is backed by a file or a cache server rather than by memory.

In Python a class-level counter is process-wide and effectively permanent, which makes it a fine memoization cache and also a fine way to leak memory and to have one user's data appear in another user's response. In PHP the same code is a per-request scratchpad: perfectly safe, and useless as a cache. That asymmetry is why PHP libraries reach for a static property freely where a Python library would be careful, and why "just cache it in a static" is real advice in one language and a bug report in the other.

Every variable carries a $, every statement ends in a semicolon, every block is braced, and indentation means nothing to the parser. The $ is not noise: because a variable is always sigil-marked, PHP can interpolate one straight into a string with no prefix and can write $$name for a variable whose name is in another variable. Nothing else in this row will surprise you again after ten minutes.

-> reaches into an instance, :: reaches into a class (constants, statics, and parent::/self::), and . is not member access at all — it is string concatenation, which is the single most common typo a Python developer makes in their first week. Note also that the instance is $this rather than an explicit first parameter, and that $this->radius has no second dollar sign on the property name.

PHP's + on two strings tries to add them as numbers, so "web" + "site" is a TypeError in PHP 8 rather than the concatenation a Python reader intends. Applied to two arrays, + is the union operator, which is a completely separate surprise covered in the arrays section. There is no * for repetition either; str_repeat does that job, and strlen replaces len — one of many places where PHP reaches for a function where Python reaches for a method or a builtin operator.

This is the shape a Laravel Blade or WordPress theme file has, and reading it is unavoidable even if you never write it. <?= is shorthand for <?php echo, and htmlspecialchars is the escaping that a Jinja or Django template would apply automatically — PHP does not escape by default, which is the root of a large fraction of the language's security reputation. Blade's {{ }} and Twig's do escape, so a modern codebase gets the Django behavior back by choosing a template engine.

A single-quoted PHP string is nearly literal — only \\' and \\\\ mean anything — while a double-quoted string interpolates variables and honors escapes like \n. That is why 'hello $name' prints the dollar sign. The heredoc (<<<TEXT) is the multi-line interpolating form, roughly Python's triple-quoted f-string; its nowdoc sibling <<<'TEXT' is the non-interpolating one. The closing marker must sit on its own line, and since PHP 7.3 it may be indented.

The practical costs are two. Chained transformations read inside-out — trim(str_replace(...)) instead of .replace(...).strip() — which is why PHP 8.5's pipe operator was such a celebrated addition. And the argument order is famously inconsistent: str_replace($search, $replace, $subject) puts the subject last while strpos($haystack, $needle) puts it first, an artifact of the standard library having grown from two different C libraries in the 1990s. There is no fixing it without breaking every program ever written, so PHP developers keep the manual open and so should you.

Until 2020 the only way to ask "does this contain that" was strpos($path, "2026") !== false — and because strpos returns 0 for a match at the start, writing the natural if (strpos(...)) silently reported "not found" for anything at position zero. That single trap generated an extraordinary number of bugs. str_contains, str_starts_with and str_ends_with fixed it, and are the direct equivalents of Python's in, startswith and endswith.

explode is split and implode is join, with the separator first in both — which is at least self-consistent, and matches Python's ",".join(...) in spirit if not in shape. implode historically accepted its arguments in either order and that leniency was removed in PHP 8, so the separator-first form is now the only one. A PHP developer never writes join, even though it exists as an alias.

A PHP string is a byte array, so strlen("café") is 5 — the length in UTF-8 bytes — and $text[3] hands back half of the é. The mb_ family (from the multibyte extension) is the Unicode-aware parallel set: mb_strlen, mb_substr, mb_strtoupper, mb_str_split. The rule in any PHP codebase handling user text is to use the mb_ function wherever one exists. Python's equivalent split is str against bytes, but there the default is the safe one, and PHP's default is not.

A "list" in PHP is just an array whose keys happen to be 0, 1, 2, …; nothing enforces that, and array_is_list() exists precisely because you sometimes need to ask. There is no tuple, so no immutable sequence and no hashable composite key — a PHP array key can only be an int or a string, which rules out {(3, 4): "corner"} entirely. And because it is one type, count() answers for both shapes where Python's len happens to as well.

A whole category of Python bug simply does not exist here: no aliasing surprise, no list(other) defensive copy, and no mutable-default-argument trap. What you lose is the ability to hand a function a container and let it fill it in — for that PHP needs an explicit &$items reference parameter, which is rare and looks alarming precisely because it is rare. The copy is lazy (copy-on-write) under the hood, so this costs nothing until something is actually modified. Objects, by contrast, are handles and behave the Python way — $b = $a on an object gives two names for one object.

The inconsistency is real and permanent, for the same backward-compatibility reason as the needle/haystack problem. The other surprise is in the output: array_filter preserves the original keys, so filtering [1..6] down to the evens yields keys 1, 3 and 5 rather than 0, 1 and 2 — which matters the moment the result is JSON-encoded, because it serializes as an object rather than an array. Wrap it in array_values() whenever you wanted a fresh list.

array_merge is the one you want: later values win, exactly like Python's | and {**a, **b}. The + operator is the array union, and it keeps the value from the left operand for any key already present — so $defaults + $chosen ignores the choice and reports size M. There is one more asymmetry: array_merge renumbers integer keys while + preserves them, which is why concatenating two lists with + silently drops elements. The spread syntax [...$a, ...$b] works on both string and integer keys since PHP 8.1 and is the modern spelling.

There is no starred rest element, so [$first, *$rest] has no equivalent and you reach for array_slice. The key-based form ["name" => $name] = $person is genuinely handy and has no Python counterpart short of person["name"] written out. Iterating a PHP array yields values by default and $key => $value when asked, which is the union of Python's for x in items and for k, v in mapping.items() in a single construct.

That is why the example copies first — the PHP idiom for sorted(x) is "assign, then sort the copy", which works only because assignment already copies. There is no key= parameter either: usort takes a full comparator returning a negative number, zero or a positive number, and the spaceship operator <=> exists to make writing one bearable. The family is large and its names encode the behavior — sort, rsort, asort (keep keys), ksort (by key), usort, uasort, uksort.

PHP function names are case-insensitive — greet() and GREET() call the same function — a legacy quirk that no style guide condones but the engine still honors. Variable names, by contrast, are case-sensitive. And every PHP function lives in a single global namespace unless the file declares one, so there is no module object to attach it to and no from module import greet; the namespace section covers what replaced that.

PHP evaluates a default expression fresh on each call, and even if it did not, the array would be copied on assignment — so the bug is unreachable from two directions. It is a small thing, but it is representative: value semantics remove an entire class of aliasing surprise that Python asks you to hold in your head. The corresponding PHP hazard is the opposite one — code that expects a callee to fill in an array it was handed, which silently does nothing.

Python's rule is that reading an outer name is free and only assigning to one needs global or nonlocal. PHP's rule is that nothing crosses the boundary in either direction: a top-level $multiplier is invisible inside a function, and global $multiplier; (or $GLOBALS['multiplier']) is required even to read it. Closures capture nothing implicitly either — the use ($factor) clause names what comes along, and it captures by value unless written use (&$factor). Constants and function and class names are the exception; those are global and always visible.

The semantics match closely: named arguments may follow positional ones, may be given in any order, and let you skip over defaults you do not care about. Two differences worth knowing. PHP has no * marker to force an argument to be keyword-only, so every parameter is usable positionally forever. And because the name is now part of the public interface, renaming a parameter in PHP is a breaking change for callers — the same trap Python has, but newer and less internalized.

There is no **kwargs: a PHP variadic collects positional arguments into a list, and named arguments that do not match a declared parameter land in the same variadic keyed by name. The spread on the calling side is the same ellipsis, so total(...[1, 2, 3]) reads exactly like total(*[1, 2, 3]). Note the declaration int ...$numbers — the type applies to each element, and passing a string among the integers is a TypeError at the call, which *numbers: int in Python does not give you. The one real loss is that a PHP variadic must be the last parameter, so there is no equivalent of Python's keyword-only def total(*numbers, scale=1); an extra option has to move in front of the variadic or into an array.

Three costs come with the translation. The steps run in the opposite order from how the comprehension reads — filter first, then map, where the comprehension puts the map expression at the front. The argument order flips between the two calls, as always. And array_filter preserves keys, so the array_values at the end is not optional if you want a clean list out. Many PHP codebases give up and use a foreach loop with an accumulator, which is longer but reads in source order and is genuinely idiomatic here rather than a failure of taste.

The fn() => arrow function (PHP 7.4) captures every outer variable it mentions, by value, automatically — which makes it behave like a Python lambda. The price is that it holds a single expression and cannot contain statements, so anything with a loop or an early return has to be the older function () use (...) form and must list its captures. Unlike a Python lambda, though, both PHP forms can carry parameter and return types, and both are real objects (instances of Closure) with bindTo and call methods for rebinding $this.

For most of PHP's history you passed the name as a string: array_map('strlen', $words), with a method spelled [$object, 'methodName'] and a static one 'ClassName::method'. All of those still work and you will read them constantly. PHP 8.1 added the first-class callable syntax strlen(...) — a literal three-dot token — which produces a real Closure, is checked at compile time rather than at call time, and can be found by an IDE. Prefer it in new code.

Because a PHP array carries its keys, foreach ($items as $key => $value) does the work of both enumerate and .items() depending on what the array holds — there is no separate function to reach for. range() exists and differs in two ways worth remembering: the end is inclusive, and it builds the whole array eagerly rather than being lazy like Python 3's. For a lazy sequence PHP uses a generator, exactly as Python does.

"0" is falsy in PHP and truthy in Python — a legacy of PHP's form-handling origins, where a checkbox submitting the string "0" meant "off". Any code that reads a numeric string from a form, a query parameter or a database and tests it with if ($value) will treat a legitimate zero as absent. The fix is the same one as everywhere else in PHP: test explicitly, with if ($value !== "") or isset(), rather than leaning on truthiness. Note that "false" and "0.0" are both truthy, which makes the rule feel arbitrary rather than learnable.

PHP's match returns a value, compares with === rather than ==, does not fall through, and throws UnhandledMatchError when nothing matches and there is no default — every one of those a fix for a switch misfeature. What it cannot do is destructure: there is no way to bind part of a value the way case {"error": message} does. The match (true) idiom in this example is how PHP developers get arbitrary conditions into the construct, and it is standard rather than a hack. Comma-separated conditions on one arm are PHP's equivalent of the | alternative.

The differences are small: the return type is spelled Generator, list() becomes iterator_to_array(), and yield from is spelled yield from in both. A PHP generator also yields keys — yield $key => $value — which fits the array model and has no Python equivalent. What PHP does not have is a comprehension to build one from, so a generator expression like (x * 2 for x in items) must be written as a generator function.

What promotion does not give you is the rest of what @dataclass generates. There is no automatic __eq__, so two Point objects with the same coordinates are == (PHP compares properties for that operator) but not ===, which compares identity; and there is no generated repr, so printing an object needs a __toString method of your own. Method names use camelCase by convention, per PSR-12, rather than Python's snake_case — the one style rule that trips up a Python developer in code review.

Reaching for a private PHP property from outside raises an Error, and there is no _ClassName__attribute back door as there is for Python's double-underscore name mangling — reflection is the only way in, and it is deliberate and visible. The three keywords are public, protected (this class and subclasses) and private (this class only, and note that a sibling instance of the same class can read another's privates). PHP also has real interfaces and final, so "this cannot be subclassed" and "this must be implemented" are statements the compiler checks rather than docstrings.

A trait is a block of methods copied into a class at compile time — Python's mixin, but flattened rather than placed in a lookup chain, so there is no MRO to reason about and a conflict between two traits is a compile error you must resolve explicitly with insteadof. Interfaces may be implemented in any number and are checked: a class that declares implements Shape without an area() of the right signature does not load. That is the abc.ABC guarantee, obtained without inheriting anything.

Defining count() on a PHP class does nothing until the class declares implements Countable; the same holds for ArrayAccess, Iterator, IteratorAggregate, Stringable and JsonSerializable. That is more ceremony than Python's pure duck typing and it buys a real check: a function declaring function total(Countable $items) cannot be handed something that merely happens to have a count method. The genuinely magic ones with no interface are __get, __set, __call and __invoke, which map to __getattr__, __setattr__, and __call__.

self:: is resolved where the code is written, so new self() inside Model always builds a Model even when called as User::create(). static:: is late static binding, added in PHP 5.3, and resolves to the class the call actually started from — which is what cls gives you for free. The rule is to write static in any factory or fluent method you expect to be inherited, and self only when you deliberately mean this exact class.

A PHP enum case is a singleton object, so === works and a match on one is exhaustive-ish (it throws UnhandledMatchError on a case you forgot). It is also usable as a type: function publish(Status $status) is checked at the call, which is the point. from() throws on an unknown value and tryFrom() returns null, a distinction Python's Status("nope") collapses into an always-raise. What PHP enums cannot do is hold state — no properties, no instance data — though they may declare methods, implement interfaces and use constants.

Because the match has no default, adding a fourth case to Priority makes label() throw UnhandledMatchError the first time it meets that case — a run-time failure rather than a compile-time one, but a loud and immediate one at the site of the omission. Static analyzers (PHPStan, Psalm) turn the same situation into a build error, which is how PHP teams get exhaustiveness checking in practice.

A readonly property may be written exactly once, from inside the declaring class's scope, so it can be set in the constructor or in a factory method and never again. That per-property grain means a class can freeze its identity fields while leaving a cache field mutable, which @dataclass(frozen=True) cannot express. What PHP does not give you is the rest of frozen dataclass behavior: no generated equality, and no hashability — although, since a PHP array key can only be an int or a string, there was nothing to be hashable for.

The type sits before the variable rather than after the keyword, and multiple types on one arm are separated by a pipe: catch (TypeError|ValueError $error). A bare catch with no type is a parse error, so PHP has no accidental equivalent of a bare except: — the closest is catch (Throwable $error), and writing it is at least deliberate. Since PHP 8 the variable itself is optional (catch (DivisionByZeroError)) when you only care that it happened.

Exception is for conditions a program is expected to handle (a file is missing, input is invalid); Error is for programmer mistakes the engine detects (a TypeError, a call to an undefined method, division by zero). Before PHP 7 the second category was a fatal error that no try could touch, and making them throwable was one of PHP 7's headline changes. The practical rule: catch (Exception $e) is the everyday catch and will not catch a TypeError; catch (Throwable $e) catches everything and belongs only at a top-level boundary.

The Exception constructor's signature is (string $message, int $code, ?Throwable $previous), and the middle argument is a numeric code almost nobody uses; that is why the 0 is sitting there. getPrevious() is __cause__. The SPL supplies a hierarchy of ready-made types — RuntimeException, LogicException, InvalidArgumentException, OutOfBoundsException — and the convention is to extend one of them rather than Exception directly, so a caller can distinguish "the world went wrong" from "you called me wrongly".

Reading a missing array key, a missing object property, or an undefined variable is a warning rather than an exception, and the expression evaluates to null. The result is that a typo in a key name produces a page that renders with a blank where a value should be — quietly wrong instead of loudly broken, which is the opposite of Python's KeyError. Every modern codebase turns warnings into exceptions with a custom error handler, or runs a static analyzer that flags them. The three tools for asking about presence differ subtly: ?? and isset() treat a key holding null as absent, while array_key_exists() is the true membership test and is the exact analogue of "b" in values.

isset() means "present and not null", which is why it reports false for a key that exists and holds null. array_key_exists() is pure membership, matching in. ?? is the null-coalescing operator and is dict.get(key, default) — crucially it also suppresses the missing-key warning, which is why you see it everywhere in PHP code. Its companion ??= assigns only when the left side is null or absent, the same as settings.setdefault(...).

If the value on the left is null, ?-> short-circuits the whole chain to null rather than raising — including any method call and any argument to it, which are never evaluated. Combined with ?? it collapses the nested-conditional shape that Python has to spell out. The thing to be careful about is that it hides the difference between "the customer has no address" and "the address has no city"; when those mean different things, write the branches.

Without the true, json_decode returns a stdClass object and you address it with ->; with it you get an associative array and [] access, which is what a Python reader expects. Encoding has the ordered-map problem in reverse: an array with keys 0, 1, 2 encodes as a JSON array, and the same array with a gap in the keys encodes as an object — which is exactly how a stray array_filter turns a list into an object in an API response. Both functions signal failure by returning false/null unless you pass JSON_THROW_ON_ERROR, which is the flag to reach for.

DateTime is mutable: $moment->add(...) changes the object in place and returns it, so handing one to a function that adjusts it corrupts the caller's value. DateTimeImmutable returns a new object instead, matching Python's datetime, and is what every style guide now mandates. The format characters are PHP's own rather than strftime's — Y-m-d H:i instead of %Y-%m-%d %H:%M — and intervals use the ISO 8601 duration spelling P10D. The constructor accepts almost any human date string, which is convenient and occasionally too clever.

So Python's re.IGNORECASE flag argument becomes a trailing i: '/error/i'. Single-quoted strings are the right choice for patterns, since a double-quoted one would try to interpolate $ anchors and would eat backslashes. The other structural difference is that captures come back through an output parameter — preg_match returns 1, 0 or false and fills $matches — rather than returning a match object, so the if and the extraction are one statement. The engine is PCRE, so the syntax itself is close to Python's and rather more capable.

There is no context manager, so the streaming form — fopen, fgets in a loop, fclose — has to close the handle itself, and does not do so on an exception. In practice a PHP developer reaches for file_get_contents and file_put_contents for anything that fits in memory, and file() when they want the lines as an array. All three accept a URL as well as a path, so file_get_contents('https://example.com') is an HTTP GET — convenient, occasionally a security problem, and disabled in hardened configurations.

use App\Billing\Invoice; is purely a compile-time alias saying "in this file, Invoice means that fully-qualified name". Getting the class defined is the autoloader's job, and it happens lazily at the moment the name is first used. There is also no module object — you cannot write invoice_module.something — and namespaces do not nest as a hierarchy the way packages do; App\Billing and App\Billing\Tax are unrelated names that merely share a prefix. Separators are backslashes, which is a genuinely awkward choice inside double-quoted strings.

The PSR-4 standard maps a namespace prefix to a directory, so App\Billing\Invoice becomes src/Billing/Invoice.php by string substitution; Composer generates that callback for you. The practical consequences are pleasant: one require 'vendor/autoload.php' at the entry point and nothing else is ever included by hand, no circular-import problem, and no import-time side effects — because a class file that does anything other than declare a class is a PSR-1 violation. The cost is that the file layout is load-bearing in a way Python's is not, and a typo in a namespace produces "class not found" rather than "file not found".

Dependencies install into vendor/ inside the project, so there is no environment to activate, nothing global to collide, and no way to run the wrong Python by accident. composer.json holds the version ranges you asked for and composer.lock holds the exact resolved versions — the split that requirements.txt conflates and that pyproject.toml plus uv.lock or Poetry have only recently brought to Python. Packagist is PyPI. The one thing Composer does not do is manage the PHP version itself; that is your system's or your container's problem, where pyenv and uv would handle it.