3.1.1 Assignment with =

The semicolon at the end of each MATLAB line is optional. Without it, MATLAB prints the contents of the variable to STDOUT—helpful for observing values during development but distracting for working code.

Python also supports chained assignment where all variables are set to the same value:

Unlike MATLAB, Python supports a conditional assignment statement that works like the ternary operator (e.g., x = (y < z) ? y : z) in C, Perl, and Java, among others. It allows assignment of either one or another value depending on a condition:

3.1.2 In-Place Updates with +=, -=, and Others

MATLAB’s a = a + 1 looks harmless enough, but replace a with an element of a nested class or structure, for example, catalog.volume(j).on_loan.count, and the text duplication becomes unwieldy.

Of course, MATLAB can perform these operations too, just not in-place.

3.1.3 Walrus Operator, :=

The last of the four Python assignment expressions, the walrus operator, or :=, was introduced in Python 3.8. It works like a conventional assignment statement with the side effect that the entire expression, both left-hand side and right-hand side, has the value of the right-hand side. The walrus operator has no MATLAB equivalent.

Here’s a simple example:

Nothing surprising here; x was set to 100. What’s not obvious is that the entire statement x := 100 also has the value of 100. We can see that if we capture the full expression with another variable:

One practical use of this behavior is inserting intermediate variables in the middle of a computation for use later. Here’s the Pythagorean theorem equation with additional variables inserted to store intermediate values of Δ_x and Δ_y:

Inserting dx := and dy := lets us save these intermediate values without disrupting the larger computation for d.

3.3.1 Tabs

Tabs are problematic and are not permitted in Python source code. They are problematic because tab widths are not standard; one person’s editor may be configured for eight spaces per tab, while another person’s editor is set up to use four. If tabs were allowed, a Python file with a mix of tabs and spaces could give completely different results for the two people—if it even passes a syntax check.

3.4.1 Brackets vs. Parentheses

In the MATLAB version, one cannot tell if G, ind, or case_N are variables or functions. The distinctions are readily apparent in Python—G and case_N are variables, while ind is a function.

3.4.2 Zero-Based Indexing and Index Ranges

Perhaps the most notable indexing difference between MATLAB and Python is that Python indices begin with zero, while MATLAB indices begin with one. Python matches most other programming languages in this regard, but, interestingly, languages with a strong mathematical bias such as MATLAB, Mathematica, Fortran, and Julia use one-based indexing.

Python’s z[1:3] returns only z[1] and z[2]; to also get z[3], our range notation would need to be z[1:4]. More generally, for the range J:K, MATLAB returns K-J+1 terms beginning at index K, while Python returns K-J terms beginning at index K.

3.4.3 Start, End, and Negative Indices

3.4.4 Index Strides

3.4.5 Index Chaining

3.5.1 Early Loop Exits

MATLAB and Python both use continue and break to, respectively, skip to the next iteration and to exit the loop.

3.5.2 Exit from Nested Loops

An irritant with both MATLAB and Python is that neither has an elegant way to leave nested loops from an inner loop because break only works for its immediately-enclosing for loop. One must employ an extra variable to let the outer loop know that the inner loop wants to break out. Some Python programmers advocate the use of exceptions to achieve this goal, but exceptions are just as clunky to code as using an extra variable.

3.7.1 Boolean Expressions and Operators

MATLAB’s “logical” constants true and false have equivalents in Python’s Boolean constants True and False. In MATLAB, one generally represents these with 1 and 0, although any non-zero value evaluates as true. Like MATLAB, Python interprets numeric zero (either integer or floating point) and empty strings, lists, sets, dictionaries, or tuples as false. Python additionally has a special constant, None, which represents uninitialized or nonexistent data (similar to NULL in C-type languages and SQL, or undef in Perl) also evaluates to false.

Common comparison operators for scalar numbers and strings (in MATLAB, these must strictly be strings and not character vectors) in both languages are shown in Table 3-2.

3.7.2 Range Tests

MATLAB evaluates these expressions as (a < b) < c, so the third one gives an unexpected result because (1 < –1) evaluates to 0 which carries into the next expression of 0 < 3. The expression then evaluates to true in MATLAB which is of course incorrect because 1 < –1 < 3 is false.

Python expands the range evaluation to (a < b) and (b < c) and therefore gives the expected result for all scalar values of a, b, and c.

3.8.1 Pass by Value and Pass by Reference

MATLAB and Python have complex answers to “are function arguments passed by value or passed by reference?” An argument passed by value is copied to a new local variable inside the function, so modifications to the argument in the function do not propagate back to the calling environment. The data copy exacts a performance penalty though—a costly one if the data is large. Functions that work with argument references are much faster, but modifications to these arguments in the function appear in the calling environment too. Sometimes, that’s desired, other times not.

MATLAB functions behave as though they are passed by value. Under the hood, MATLAB actually passes arguments by reference to get the performance benefit. However, if an argument is updated inside the function, MATLAB will first make a local copy of it—this technique is known as “copy on write.” The argument update then remains local to the function. One technique that can bypass the copy on write logic is to define the same variable in a function’s input and output sections, for example, function [M] = update(M, x). If the right conditions are met,³ MATLAB skips the copy and works directly with the contents of the variable.

Python also has a mixed story here. Scalars are passed by value, but iterables (lists, dictionaries, tuples, NumPy arrays, sets) are passed by reference—mostly. Wholesale replacement of an iterable does not work, but reassignment of every item within an iterable is possible for lists, dictionaries, and arrays. The following examples illustrate these points.

3.8.2 Variable Arguments

3.8.3 Keyword Arguments

Python supports an even more flexible version of keyword arguments that accepts any keyword and value pair. This is done by prefixing a variable in the calling arguments with two asterisks to define it as a dictionary:

A pair of calls passing in whatever comes to mind:

3.8.4 Decorators

Python supports a concept known as a function decorator which has no counterpart in MATLAB. A decorator is essentially a function which wraps another function. Decorators are useful for adding functionality, for example, collect timing information or add debug statements, to existing functions without modifying those functions. Decorators are applied to functions by preceding the function definition with a line starting with the @ symbol and followed immediately by the decorator’s name.

This simple example applies the timer decorator to functions sleeper() and add_numbers() . Each time either of these functions runs, the decorator reports how long the call takes. (The if __name__ == "__main__": main() line is explained in Section 3.14.2.)

Output:

3.8.5 Type Annotation and Argument Validation

MATLAB’s argument block shown earlier enforces argument types and sizes if these are provided; pass a variable with the wrong type or size and MATLAB will stop with an error. Python supports type annotations for function arguments and function return types, but as of Python 3.8, these are merely hints for code editors such as PyCharm and Visual Studio Code to enable features like code completion and type mismatch warnings. Type violations are not enforced by Python at runtime.

The MATLAB function is considerably longer than the one in Python, but it also does more work; the MATLAB version validates input, while the Python version accepts anything—and fails accordingly when inputs are invalid.

3.8.6 Left-Hand Side Argument Count

Another advantage MATLAB has over Python is that a MATLAB function can know how many arguments it is expected to return—this count is stored in the variable nargout—and therefore can perform different actions depending on what the caller asks for. An example is the eig() eigenvalue function. If the left-hand side has one variable, eig() returns only the eigenvalues. If the left-hand side has two variables, eig() returns eigenvectors and eigenvalues.

Python functions have no mechanism that tells them how many items appear to the left of an equal sign. To achieve the same functionality, a Python function would need to take an additional argument that indicates the number of return values desired.

3.9.1 yield, next()

Generators are regular Python functions that return a value with the yield keyword instead of return. Each successive call returns the next item in the sequence:

Generators are often the target of for loops or appear in a while statement where each successive value is retrieved by calling next() on the generator object.

3.9.2 range()

If an explicit array is needed in Python, one can call list() on the iterator to expand every term. Better still, one can use NumPy’s arange() function to create a NumPy array which permits vector operations.

A brief overview of NumPy appears in Section 4.​1, while Chapter 11 covers NumPy in depth.

3.11.1 Docstrings

3.14.1 Namespace

A namespace is the set of all the variable and function names that are in scope in a program. For example, the NumPy module has a cosine function that works on both scalars and arrays. To use this function, we first have to load, or import, the NumPy module with import numpy and then refer to the cosine function by its full name, numpy.cos(). This extra step of importing modules strikes many MATLAB programmers as cumbersome. In contrast, when one installs a MATLAB toolbox, all functions in that toolbox are immediately available. While this may seem convenient, it can also introduce problems because common function names, such as open(), can come from the core MATLAB library or from any toolbox that defines the same function. Python’s use of namespaces removes ambiguity about a function’s origin.

Modules, or functions from within modules, may be loaded into a Python session in three different ways.

3.14.2 def main()

When a Python program imports a module, even if it just cherry-picks individual functions using the from X import Y notation, Python will run the entire module file before proceeding to the next line of the program. This can be problematic if you want to reuse functions from an older program because as soon as you import from that older program, Python will run it.

There’s a simple solution to protect yourself from inadvertent code execution: just wrap the main part of your program—the entry point and code after it—in a function (typically called main()). That way, when the file is imported by another program, the main part won’t do anything.

This raises the next issue of how do you get main() to run when you invoke the file as a program, that is, not as an import from another program, but as an executable unto itself? The solution to that is to end your program file with the lines

This tells the Python interpreter that if the file itself is being run (rather than imported), it should call main(). Flouting convention, I generally combine the lines so my programs end with

3.14.3 Module Search Path

A sample session looks like this.

Python modules have an attribute, .__path__, that contains the name of the directory from where the module was loaded:

This can be a useful troubleshooting aid on large projects if developers simultaneously work on multiple versions of the same module. The which command in MATLAB will only resolve to a file path when the function name is unique in the search path.

3.14.4 Installing New Modules

As of October 2021, more than 333,000 freely available Python modules can be found at the Python Package Index (PyPI) website, https://pypi.org. Think of the PyPI as Python’s analog to MATLAB’s File Exchange, but without the File Exchange’s necessity for authenticating with a MATLAB account. As with the File Exchange, code on the PyPI will vary widely in quality. Any PyPI package can be installed easily on computers attached to the Internet with the command pip install X, where X is the name of the desired module.

If you are using the recommended Anaconda distribution of Python though, the better choice is to install using the conda package manager which searches for modules and packages in Anaconda’s curated repository:

conda has a more sophisticated dependency resolver than pip, and its packages are more rigorously examined for security issues. Once a consistent set of dependencies is computed, conda will offer to downgrade and/or upgrade existing modules—even Python itself—to accommodate your request.

A downside to conda is the Anaconda repository is much smaller than PyPI so it is possible the module you want to install can’t be found. There’s a second tier of the Anaconda repository known as “conda-forge,” a github.com hosted collection of community-provided contributions that augment the official Anaconda collection. You can configure conda to also look at conda-forge with

3.14.5 Module Dependency Conflicts and Virtual Environments

Dependency resolution over hundreds of interdependent modules and packages is a surprisingly complex task that conda sometimes can’t solve. Making matters worse, users sometimes manually install or use pip in addition to conda to install modules, leaving an installation with incompatible dependencies. As a result, the entire Python installation could be corrupted, forcing a complete reinstall.

The cleanest solution is to install a collection of modules related for a specific task into a conda environment as described in Section 2.​5.