# 5 Best Ways to Flip and Invert a Matrix in Python

Rate this post

π‘ Problem Formulation: Let’s take on the challenge of flipping a 2D matrix both horizontally and vertically and then inverting its elements. For instance, given an input matrix `[[1, 0], [1, 1]]`, the goal is to transform it into `[[1, 1], [0, 0]]` – flipped and inverted. In this article, you’ll learn how to efficiently achieve this using different methods in Python.

## Method 1: Using Nested List Comprehension

This method uses list comprehension to flip and invert the matrix. It flips the matrix by reversing the inner lists, then inverts 1s to 0s and vice versa using a nested list comprehension. No additional libraries are required, making it a clean, native Python solution.

Here’s an example:

```matrix = [[1, 0], [1, 1]]

flipped_inverted_matrix = [[1 - i for i in row[::-1]] for row in matrix]
print(flipped_inverted_matrix)
```

Output:

```[[1, 1], [0, 0]]
```

The line `[[1 - i for i in row[::-1]] for row in matrix]` first reverses each row with `row[::-1]` and then inverts 0s to 1s and 1s to 0s by subtracting each element from 1. It is a concise and readable way to achieve both flip and invert operations in a single line.

## Method 2: Using NumPy

NumPy, a powerful library for numerical computing, provides functions such as `np.flip()` and `np.invert()` to flip and invert a matrix, respectively. This combination makes the task incredibly efficient, leveraging the optimized C backend of NumPy.

Here’s an example:

```import numpy as np

matrix = np.array([[1, 0], [1, 1]])

flipped_inverted_matrix = np.invert(np.flip(matrix, axis=1))
print(flipped_inverted_matrix)
```

Output:

```[[1 1]
[0 0]]
```

The code utilizes NumPy’s `flip()` function with `axis=1` to flip the matrix horizontally and `invert()` to convert True values to False, effectively inverting 1s to 0s and 0s to 1s. It’s worth noting that NumPy arrays support these operations natively and efficiently.

## Method 3: Using zip and reversed

This approach flips a matrix using the `zip()` function combined with `reversed()`, then iterates over each element to invert it. It benefits from Python’s iterator protocol for flipping and uses simple element-wise operation to invert.

Here’s an example:

```matrix = [[1, 0], [1, 1]]

flipped = zip(*reversed(matrix))
flipped_inverted_matrix = [[1 - i for i in row] for row in flipped]
print(flipped_inverted_matrix)
```

Output:

```[[1, 1], [0, 0]]
```

The `zip(*reversed(matrix))` expression flips the matrix while `[[1 - i for i in row] for row in flipped]` inverts it. This method is elegant, but it may be less intuitive to those unfamiliar with `zip()` and sequence unpacking.

## Method 4: Using pandas DataFrame

If you are working within a data analysis context, using pandas DataFrame methods like `iloc[]` for flipping, and `applymap()` for inverting can be very handy. It allows for clear semantics and ease of integration into data analysis workflows.

Here’s an example:

```import pandas as pd

matrix = pd.DataFrame([[1, 0], [1, 1]])

flipped = matrix.iloc[:, ::-1]
flipped_inverted_matrix = flipped.applymap(lambda x: 1 - x)
print(flipped_inverted_matrix)
```

Output:

```   0  1
0  1  1
1  0  0
```

The `matrix.iloc[:, ::-1]` inverts the column order for flipping, and `flipped.applymap(lambda x: 1 - x)` applies a function to each cell to invert the binary values. While powerful, this method requires the overhead of using pandas, which may be unnecessary for simple matrix manipulations.

## Bonus One-Liner Method 5: Using functools and operator

This one-liner uses the `functools.reduce()` function in combination with the `operator.xor()` function to flip and invert a matrix. It’s a functional programming approach that, while concise, isn’t as readable as other methods.

Here’s an example:

```from functools import reduce
import operator

matrix = [[1, 0], [1, 1]]

flipped_inverted_matrix = [list(reduce(operator.xor, row[::-1], 1)) for row in matrix]
print(flipped_inverted_matrix)
```

Output:

```[[1, 1], [0, 0]]
```

The code uses Python’s `functools.reduce()` with the `operator.xor()` to flip and invert the matrix through a bit manipulation technique. The `row[::-1]` flips the row, and `xor` toggles the bits. This method is great for those who appreciate functional programming tricks in Python.

## Summary/Discussion

• Method 1: Nested List Comprehension. This is the simplest and most Pythonic approach. However, it may not perform as well with large matrices compared to NumPy-based solutions.
• Method 2: Using NumPy. Highly efficient and concise. The main downside is that it requires an external library that may not be desired for all projects.
• Method 3: Using zip and reversed. Readable and utilizes built-in functions. The flipping operation is a bit abstract for those not familiar with these functions.
• Method 4: Using pandas DataFrame. Integrates well with data analysis pipelines and is highly readable. It introduces overhead that’s unwarranted for simple matrix operations.
• Bonus Method 5: Using functools and operator. An interesting functional programming approach, but perhaps the least readable and thereby not suitable for all coders.