Table of Contents

## Problem Formulation

Given a list of size `n`

and two indices `i,j < n`

.

Swap the element at index `i`

with the element at index `j`

, so that the element `list[i]`

is now at position `j`

and the original element `list[j]`

is now at position `i`

.

**Examples:**

- Swapping indices
`0`

and`2`

in list`[`

modifies the list to**1**, 2,**3**]`[`

.**3**, 2,**1**] - Swapping indices
`1`

and`2`

in list`[1,`

modifies the list to**2**,**3**]`[1,`

.**3**,**2**] - Swapping indices
`1`

and`3`

in list`['alice',`

modifies the list to**'bob'**, 'carl',**'denis'**]

.`['alice',`

**'denis'**, 'carl',**'bob'**]

## Method 1: Multiple Assignment

To swap two list elements by index `i`

and `j`

, use the multiple assignment expression `lst[i], lst[j] = lst[j], lst[i]`

that assigns the element at index `i`

to index `j`

and vice versa.

lst = ['alice', 'bob', 'carl'] i, j = 0, 2 # Swap index i=0 with index j=2 lst[i], lst[j] = lst[j], lst[i] print(lst) # ['carl', 'bob', 'alice']

The highlighted line works as follows:

- First, it obtains the elements at positions
`j`

and`i`

by running the right-hand side of the assignment operation. - Second, it assigns the obtained elements in one go to the inverse indices
`i`

and`j`

(see left-hand side of the assignment operation).

To help you better understand this code snippet, I’ve recorded a quick video that shows you how the generalization of multiple assignment, i.e., *slice assignment*, works as a Python One-Liner:

## Method 2: Swap Two Elements by Value Using indexof()

Let’s quickly discuss a variant of this problem whereby you want to swap two elements but you don’t know their indices yet.

To swap two list elements `x`

and `y`

by value, get the index of their first occurrences using the `list.index(x)`

and `list.index(y)`

methods and assign the result to variables `i`

and `j`

, respectively. Then apply the multiple assignment expression `lst[i], lst[j] = lst[j], lst[i]`

to swap the elements.

The latter part, i.e., swapping the list elements, remains the same. The main difference is highlighted in the following code snippet:

lst = ['alice', 'bob', 'carl'] x, y = 'alice', 'carl' # Get indices i and j associated with elements x and y i, j = lst.index(x), lst.index(y) # Swap element at index i with element at index j lst[i], lst[j] = lst[j], lst[i] print(lst) # ['carl', 'bob', 'alice']

Do you need a quick refresher on the `list.index()`

method?

💡 **Background**: The `list.index(value)`

method returns the index of the `value`

argument in the `list`

. You can use optional `start`

and `stop`

arguments to limit the index range where to search for the value in the list. If the value is not in the list, the method throws a `ValueError`

.

Feel free to also watch the following quick explainer video:

## Python One-Liners Book: Master the Single Line First!

**Python programmers will improve their computer science skills with these useful one-liners.**

*Python One-Liners* will teach you how to read and write “one-liners”: ** concise statements of useful functionality packed into a single line of code. **You’ll learn how to systematically unpack and understand any line of Python code, and write eloquent, powerfully compressed Python like an expert.

The book’s five chapters cover (1) tips and tricks, (2) regular expressions, (3) machine learning, (4) core data science topics, and (5) useful algorithms.

Detailed explanations of one-liners introduce ** key computer science concepts **and

**. You’ll learn about advanced Python features such as**

*boost your coding and analytical skills**,*

**list comprehension****,**

*slicing***,**

*lambda functions***,**

*regular expressions***and**

*map***functions, and**

*reduce***.**

*slice assignments*You’ll also learn how to:

- Leverage data structures to
**solve real-world problems**, like using Boolean indexing to find cities with above-average pollution - Use
**NumPy basics**such as*array*,*shape*,*axis*,*type*,*broadcasting*,*advanced indexing*,*slicing*,*sorting*,*searching*,*aggregating*, and*statistics* - Calculate basic
**statistics**of multidimensional data arrays and the K-Means algorithms for unsupervised learning - Create more
**advanced regular expressions**using*grouping*and*named groups*,*negative lookaheads*,*escaped characters*,*whitespaces, character sets*(and*negative characters sets*), and*greedy/nongreedy operators* - Understand a wide range of
**computer science topics**, including*anagrams*,*palindromes*,*supersets*,*permutations*,*factorials*,*prime numbers*,*Fibonacci*numbers,*obfuscation*,*searching*, and*algorithmic sorting*

By the end of the book, you’ll know how to ** write Python at its most refined**, and create concise, beautiful pieces of “Python art” in merely a single line.

*Get your Python One-Liners on Amazon!!*

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com. He’s author of the popular programming book Python One-Liners (NoStarch 2020), coauthor of the Coffee Break Python series of self-published books, computer science enthusiast, freelancer, and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.