4.2.1 Strings, Character Arrays, and Byte Arrays

While both languages have similar concepts of strings, they differ in how and what their more simpler forms, character arrays (MATLAB) and byte arrays (Python), contain. MATLAB char arrays are essentially primitive strings where each character is stored in two bytes. Python byte arrays are a collection of uint8 values that can look like strings if the byte values fall in the range of printable ASCII characters. A MATLAB string is actually a 1x1 cell array containing a 1xN array of chars. You’ll occasionally see MATLAB strings indexed by {1} since this construct returns the underlying char array---handy for numeric indexing of substrings.

A commonly seen error in Python is TypeError: a bytes-like object is required, not 'str'. This happens when attempting to perform a string operation, covered in the next section, using a byte array. The simple fix is to apply the .decode() method on the byte array to turn it into a string.

4.2.2 String Operations

Python strings, like all data containers and functions in Python, are objects. Their attributes and methods can be queried interactively in ipython by adding a period after a string variable, then hitting the <TAB> key :

MATLAB has a similar capability with its methods and methodsview commands, but these are applied to the data type (or “class” in MATLAB terminology) rather than to a variable:

Common string operations are described in greater detail in the following sections.

4.2.3 Formatting

Both MATLAB and Python can use C language–style formatting for strings:

Python additionally supports a convenient feature known as f-strings that allow variables and expressions to be embedded within the format string instead of appearing afterward as arguments. Note the f" prefix on the format string:

The < symbol on the string format <5s means “left justify.” The formatting designations are optional. Without them, the output is

4.2.4 Separate a String into Words

A frequently performed operation for reading input data is splitting a string into an array of words delimited by whitespace, commas, or other characters. Python’s .split() method, like MATLAB’s strsplit() function, will default to splitting the string on whitespace; passing an argument will split on that character or substring.

Outputs from split operations are a cell array in MATLAB and a list in Python. These containers will be described in detail in Section 4.​3.

Splitting comma-separated value (.csv) files is such a ubiquitous task that both MATLAB and Python have special methods for this. Chapter 7 has an extensive section on working with .csv files.

4.2.5 Tests on Strings

When working with numeric data, MATLAB’s notation is generally terser than Python’s. The reverse is true for strings.

4.2.6 String Searching, Replacing with Regular Expressions

Python has a complete Perl-compatible regex engine, while MATLAB implements only a subset of the Perl regex metacharacters. The underlying mechanisms of invoking the pattern search and extracting results also differ.

4.2.7 String Templates

String templates are useful for stamping out copies of text that is mostly boilerplate. Examples include simple HTML documents (we’ll see an example of this in Section 7.​17.​2) and input files for other programs when performing a parameter sweep where just one value changes in each file.

The Python strings module from the standard library has a function, Template(), that returns a template object whose entries can be replaced by calling the object’s _substitute() method. Here’s an example:

I’m unaware of a text templating mechanism for MATLAB.

The Jinja2² template engine offers much more power than the Python standard library’s string.Template(). It offers text generation with loops, conditional expressions, template hierarchies with inheritance, macros, filters, Python code execution, and supports include files.

4.3.1 Initialize an Empty List

An empty cell array of a given size can be allocated in MATLAB with the cell() function. If given only one numeric argument, N, it will return an N x N collection of empty cells—not always the desired outcome. To simply make N empty cells, we’ll need to supply a second dimension of 1.

4.3.2 Create a List with Given Values

Additional methods exist in both languages to convert other containers into lists. MATLAB has cell(), mat2cell(), and num2cell(), while in Python one can use the list() function or write a list comprehension (described in Section 4.3.14).

4.3.3 Get the Length of a List

4.3.4 Index a List Item

Negative indexing has a drawback in that it can mask latent bugs. Say you write code that only accesses list items with zero or positive indices. If the code has a logic error which permits an index to become negative, instead of crashing with an index error like MATLAB, your code will continue to run—and yield bad results.

4.3.5 Extract a Range of Items

Note that in MATLAB, a = {100:106} produces a cell array with a single item (a matrix of seven values), which is not what we’re after:

Cell arrays and list slices are accessed similarly as the following examples illustrate.

Extract the first three items

Python’s range operator differs a bit from MATLAB’s. In Python, the start index may be omitted if it is 0, and the value for the end index is not part of the returned list. In other words, [:3] returns list items 0, 1, and 2.

4.3.6 Warning—Python Index Ranges Are Not Checked!

Although a single list index raises an IndexError if it exceeds the bounds of the list, index ranges have no such checks.

In Python, out-of-bounds index ranges merely return an empty list; they will not raise an error.

There’s no error! What is going on? Python will raise an error when a list is indexed by a single value outside the index bounds, but silently accepts index ranges which are out of bounds. Unchecked index ranges offer rich opportunities for code errors to pass undetected. They place the responsibility for checking start and end index values on the developer.

Another example is splitting a collection into evenly sized sets and not having to bother with leftovers on uneven splits. Here, we group the numbers 1 through 20 into three evenly sized sets:

Obviously , 20 is not evenly divisible by 3, but we don’t have to bother with that detail; the output sets have the desired counts of 7, 7, and 6 members:

Had array bounds been checked, the last iteration would have raised an error since the print statement attempts to access a nonexistent 21st element. Instead, Python just returns nothing for the missing item.

The equivalent output can be produced with MATLAB code that caps the ending index at each iteration:

4.3.7 Append an Item

Items can be added to MATLAB cell arrays simply by introducing a new index. The new index can be any integer value; it need not be an increment of the last index in the cell array. If there is a gap of indices, the skipped terms are created and populated with an empty matrix.

4.3.8 Append Another List

4.3.9 Preallocate an Empty List

Note that two dimensions were passed to MATLAB’s cell(). If we were to call cell(4) instead of cell(4,1), the result would be a 4 × 4 cell array.

4.3.10 Insert to the Beginning (or Any Other Position) of a List

4.3.11 Indexing Nested Containers

Entries within nested cell arrays are indexed in MATLAB with both braces and parentheses; the braces index into the cell array, and parentheses index into the item within the cell.

4.3.12 Membership Test: Does an Item Exist in a List?

We saw at the beginning of this section that the ismember() function works for MATLAB cell arrays. I’ve not had luck using ismember() with mixed-type data in MATLAB 2020b though. (If all entries are numeric, the cell array can be converted to a matrix after which the find() function can be used.) Instead, I use this small function to check if an item exists in a cell array:

Returning briefly to ismember() in MATLAB, the six attempts at checking if 102 is in a all yield the same error:

4.3.13 Find the Index of an Item

4.3.14 Apply an Operation to All Items (List Comprehension)

4.3.15 Select a Subset of Items Based on a Condition

4.3.16 How Many Times Does an Item Occur?

4.3.17 Remove the First or Last (or Any Intermediate) List Item

4.3.18 Remove an Item by Value

If one knows the index of an item to remove from a list, the .pop(index) method described earlier works nicely. But what if you only know the value of the item to remove? In this case, the .remove() method is useful. Note that only the first occurrence of the matched value is removed. A ValueError exception is raised if the requested value doesn’t appear.

4.3.19 Merging Multiple Lists

Related data items in separate lists must sometimes be grouped into individual pairwise (or, more generally, n-wise) items. For example, say you have a list of letters, ‘A’, ‘B’, ‘C’, …, and a corresponding list of those letters’ ASCII values, 65, 66, 67, …, and you want to merge these two lists into a single new list of letter and ASCII value pairs, [ (‘A’, 65), (‘B, 66), … ]. MATLAB allows one to create a new cell array by stacking existing cells, while Python has a function, zip(), which combines the lists. (Imagine a zipper joining two sections of fabric.)

zip() is frequently seen in for loops that need to step through multiple lists in lockstep:

4.3.20 Unmerging Combined Lists

Prefixing a list or numeric array with an asterisk, as with *both earlier, means “expand the terms.” In other words, if x = [9, 'b'], then x is a single item, a list. *x, however, means two separate terms, 9 and 'b'. The asterisk can be thought of as removing the outer container.

4.3.21 Sort a List

4.3.22 Reverse a List

Finally, the sequence of a Python list can be flipped with either the reversed() function or with the list’s .reverse() method ; using the .reverse() method alters the list in-place. MATLAB can reverse terms of vector or cell array x with fliplr(x) or flip(x,2).

4.6.1 Iterating over Keys

Python (as of version 3.6) iterates over dictionary keys in the order they were inserted, same as Map in JavaScript. In contrast, std::map in C++ iterates over keys in sorted order. (Before v3.6, Python dictionaries behaved more like Perl and JavaScript hashes which can return keys in any order.)

4.6.2 Testing for Key Existence

As dictionaries are heavily used in Python, KeyError tends to be among the more frequent error messages Python programmers see.

4.6.3 Iterating over Keys, Sorting by Key

Insert order is not always the desired order to iterate through a dictionary. Frequently, one may wish to traverse a dictionary based on ascending or descending sort order of its keys or values. In this case, we have to employ the sorted() function (and optionally pass it the desired comparison operator).

The expression key=lambda X: len(X) bears additional clarification. The letter X is an arbitrary variable that represents the function’s argument, which will be the dictionary keys, for example, 'France'. The lambda’s return value, len(X), is the length of the dictionary key, or the number 5 when X is 'France'. Our case lambda function will cause sorted() to return the dictionary keys from the shortest length, 3 for 'USA', to the longest, 7 for 'Germany'.

4.6.4 Iterating over Keys, Sorting by Value

4.6.5 Tuples As Keys

All dictionary examples so far have used scalar keys. Tuples are, in a sense, multivalued scalars and can also be used as dictionary keys. This enables simple solutions to data relationships that involve multiple inputs.

You could store the same information in a double-level dictionary, but it would be messier to code and slower to traverse.

4.6.6 List Values

Dictionary values are not limited to scalars; they may be any Python container, including other dictionaries. Dictionaries of lists are a popular combination. Among other things, these can store tree structures—the parent node is the dictionary key, and its list items are child nodes. This tree, for example

4.7.1 Method 1: namedtuple

4.7.2 Method 2: SimpleNamespace

One can check whether or not a field name exists in the structured variable with the hasattr() function , directly analogous to MATLAB’s isfield() function .

4.7.3 Method 3: Classes

As with SimpleNamespace—and any Python object for that matter—the existence of attributes can be checked with hasattr() and iterated over by accessing the object’s underlying . __dict__ dictionary. See Section 4.7.2 for an example.

The power of using classes as data containers is the ability to add methods that perform value-added computations with the data values. As we’ll see in the next section though, data classes give us a fusion of concise notation to define the data structures and the ability to define methods that operate on the values. Data classes are therefore better choices for storing structured data than conventional classes.

4.7.4 Method 4: Data Classes

Data classes, introduced in Python 3.7, allow one to create structured variables that can include custom methods. In essence, they are a convenience mechanism that defines a class with automatically generated underlying code for the __init__() constructor, __str__() to produce a string representation of the data, and several other methods. Items within data classes have associated types, but, as with type annotations (Section 3.​8.​5), by default Python will not enforce a type violation.

Type enforcement can be added with the Pydantic module, though (Section 4.7.4.5), to achieve a capability similar to optional variable properties defined in MATLAB classes (Section 10.​1). Another difference between MATLAB classes and Python classes, including its data classes, is that MATLAB can explicitly define private methods, while Python cannot (this is covered in greater detail in Section 10.​1.​1).

Nothing exciting here; the real fun begins when we add methods to the data class. We’ll begin by adding a function that computes the distance of the point from the origin:

Now after we define a point, we can compute its distance by calling mag() :

4.7.4.2 Relationships Between Dependent Data Classes

The utility of data classes becomes more apparent when data classes are nested, that is, they include variables whose types are also data classes. To explore nested data classes more fully, we’ll use the Python faker⁶ module, explained in more detail in Appendix B, to generate names of people, phone numbers, and names of companies. These will be stored in data classes Person, Phone, and Company, respectively.

Each person can have one or more phones and work at one company, and a company can have one or more employees. If the data were stored in an SQL database, the entity relationship would resemble this diagram:

Before we generate data, we’ll need to explore two more important data class properties: (1) the ability to modify data class properties dynamically and (2) that data class assignments as those for any mutable object⁷ are by reference (ref. Section 4.8).

4.7.5 Enumerations

Python enumerations are iterables, meaning we can loop over them. Additionally, the string and integer representations of each enumerated item can be found with the item’s .name and .value attributes.

MATLAB does not provide a way to iterate over enumerated items.