Adventures in Machine Learning

Python’s Ellipsis: A Game-Changer for Coding Efficiency

Python’s Ellipsis: A Comprehensive GuidePython is a high-level and easy-to-read programming language that has gained massive popularity in recent years. However, it may come as a surprise to many that it contains a unique feature called the Ellipsis.

This article aims to provide you with a comprehensive guide to Python’s Ellipsis, covering its definition, usage, and applications developed by big tech companies such as Google, NVIDIA, and Microsoft.

Definition and Usage

In Python, the Ellipsis is a representation of a missing piece of code or data. It is a non-operational keyword, symbolized by three periods (‘…’), which is used as a placeholder to indicate a continuation or an omission of code.

The typical use of Ellipsis in Python programming is to specify that a function or method’s implementation is left untouched.

Placeholder in Python

The Ellipsis is often used as a placeholder in Python, especially when working with nested structures. One of the most popular cases when using the Ellipsis is to replace missing code that has not yet been written.

In such cases, the developer will use the pass keyword to indicate the presence of code, like this:


def some_function():

… “`

Here, the Ellipsis inside the function serves as a placeholder for the missing code that will implement some_function().

This practice is beneficial when working with complex applications and frameworks that have many loose ends.

Stubs and Type Checking

In Python, type checking is the process of verifying the type of values passed between functions, methods, and objects. Python has a dynamic type system that allows developers to define variables without specifying their data type.

However, this opens up the possibility of runtime errors. To mitigate this problem, developers use type checking tools to ensure the code’s correctness.

One tool that has been built around this practice is the Typeshed repository. Typeshed is a collection of library stub files that are used for type annotation and checking.

The Ellipsis is often used as a placeholder in such stub files to indicate a function’s return type:


def get_data() -> …:


Here, Ellipsis is used as a placeholder for the return type of the get_data() function.

This encourages the developer to go back and define the function’s return type, making the code more robust.

Using Ellipsis in Type Hints

Python developers often use type hints to improve the readability and maintainability of their code. Type hints act as a roadmap that allows other developers to understand what data types to expect when interacting with a function or method.

The Ellipsis can be used in type hints in some unique ways.

Tuple of Homogeneous Type

In Python, a tuple is a collection of different data types. However, it is also possible to create a tuple of homogeneous type, which means that the tuple’s elements should have the same data type.

Applying this definition, we can use the Ellipsis in a tuple to make it homogeneous, like this:


def some_function() -> Tuple[float, …, float]:

… “`

Here, the Ellipsis serves as a placeholder for the same datatype as the first element of the tuple.

This enables the developer to create type hints for large tuples easily.

Substitution for a List of Arguments

Using the Ellipsis as a substitution for a list of arguments is another significant hack. You can append Ellipsis to a callable function’s argument list to indicate that the function accepts multiple arguments, like this:


def concatenate(*args, sep: str = ” “) -> str:

return sep.join(args)

def some_function(*args) -> str:

return concatenate(…, sep=”-“)


Here, the concatenate() function concatenates each argument passed to it using the ‘sep’ variable.

In the some_function() function, we use Ellipsis to represent a variable number of arguments that are passed on to the concatenate() function.


In conclusion, Python’s Ellipsis is an essential feature that helps developers write more robust and maintainable code. It acts as a placeholder for missing or in-progress code, promotes the use of type checking and provides a unique way of using type hints to indicate homogeneous tuples and variable number of arguments.

Understanding how to use Ellipsis intelligently is crucial, especially when developing complex and extensive applications.

3) Slicing in NumPy with Ellipsis

NumPy is a popular Python library that is used for scientific computing. It offers powerful functions for working with large, multi-dimensional arrays and matrices.

One of the most important features of NumPy is the ability to slice arrays. Slicing allows you to extract specific parts of a multi-dimensional array, and it is crucial when working with large data sets.

In this section, we will discuss how to slice multi-dimensional arrays in NumPy using the Ellipsis.

Slicing Multidimensional Arrays

Multi-dimensional arrays in NumPy can be sliced using the regular Python indexing syntax. The formula for slicing is as follows:


array[start:stop:step, start:stop:step, …]


Each dimension of the array is separated by a comma.

The start, stop, and step values indicate the range of the slice for each dimension. For instance, if we have a two-dimensional array, we can slice it using the following code:


import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# slice second column

print(a[:, 1])


This will print `[2, 5, 8]`, which is the second column of the array. However, the syntax for slicing multi-dimensional arrays with many dimensions can become quite verbose.

This is where the Ellipsis comes in.

Abbreviation of Slicing Syntax

The Ellipsis allows us to abbreviate the slicing syntax for multi-dimensional arrays in NumPy. It serves as a shorthand for “all dimensions not explicitly stated.”

Let’s consider an example:


import numpy as np

a = np.random.rand(3, 4, 5, 6)

# slice a random element

print(a[…, 2])


The `a[…, 2]` syntax indicates that we want to slice every dimension of the array except for the last dimension. Then, we select the third index of the last dimension, which gives us a random element from the array.

Using the Ellipsis, we can also achieve more complex slicing operations. For example, let’s take a 3D array and slice the first two dimensions, while selecting every second element in the third dimension:


import numpy as np

a = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])

# slice first two dimensions, select every second element in third dimension

print(a[:, :, ::2])


This will print `[[[ 1, 3], [ 4, 6]], [[ 7, 9], [10, 12]]]`, which is the result of the slicing operation.

4) Other Uses of Three Dots in Python

The Ellipsis is not only used in NumPy for slicing multi-dimensional arrays. In fact, it has other uses in Python programming as well.

Secondary Prompt in the Python Interactive Shell

When using the interactive Python shell, typing a statement that spans multiple lines can result in the primary prompt (`>>>` by default) being repeated on each line. To indicate that the input is part of an ongoing statement, Python provides a secondary prompt (`…` by default).

For instance, let’s say we want to define a function that takes in a list of integers and returns the product of all the elements:


def product(numbers):

result = 1

for num in numbers:

result *= num

return result


If we type this code into the interactive shell, each line gets its own primary prompt:


>>> def product(numbers):

… result = 1

for num in numbers:

… result *= num

return result

… “`

Here, the `…` prompt is used to indicate that the `def` statement continues onto the next lines.

This prevents clutter in the shell and makes it easier to read the code.


The Ellipsis is an essential feature in Python programming that serves as a placeholder to indicate missing or in-progress code. In NumPy, it is used to abbreviate the slicing syntax for multi-dimensional arrays, enabling developers to write more readable code.

Additionally, the Ellipsis is used as a secondary prompt in the Python interactive shell to indicate ongoing statements. Knowing how to use the Ellipsis correctly can be invaluable when working with complex applications and frameworks.

In conclusion, the Ellipsis is a unique feature of Python that can be used as a placeholder for missing or unfinished code. It is widely used in NumPy to abbreviate the slicing syntax for multi-dimensional arrays, making code easier to write and read.

The Ellipsis also serves as a secondary prompt in the Python interactive shell. Understanding how to use the Ellipsis can significantly improve the quality of your Python code and make you a more efficient and effective developer.

Popular Posts