# Swapping 1 with 0 and 0 with 1 in a Pythonic way

Each Answer to this Q is separated by one/two green lines.

In some part of my Python program I have a val variable that can be 1 or 0. If it’s 1 I must change to 0, if it’s 0 I must change to 1.

How do you do it in a Pythonic way?

``````if val == 1:
val = 0
elif val == 0:
val = 1
``````

it’s too long!

I did:

``````swap = {0: 1, 1:0}
``````

So I can use it:

``````swap[val]
``````

Other ideas?

This isn’t pythonic, but it is language neutral. Often `val = 1 - val` is simplest.

The shortest approach is using the bitwise operator XOR.

If you want `val` to be reassigned:

``````val ^= 1
``````

If you do not want `val` to be reassigned:

``````val ^ 1
``````

Since `True == 1` and `False == 0` in python,

you could just use `var = not var`

It will just swap it.

Just another possibility:

``````i = (1,0)[i]
``````

This works well as long as `i` is positive, as dbr pointed out in the comments it doesn’t work for `i < 0`.

Are you sure you don’t want to use `False` and `True`? It sounds almost like it.

In your case I recommend the ternary:

``````val = 0 if val else 1
``````

If you had 2 variables to swap you could say:

``````(a, b) = (b, a)
``````

To expand upon the answer by “YOU”, use:

``````int(not(val))
``````

Examples:

``````>>> val = 0
>>> int(not(val))
1

>>> val = 1
>>> int(not(val))
0
``````

Note that this answer is only meant to be descriptive, not prescriptive.

Here’s a simple way:

``````val = val + 1 - val * 2
``````

For Example:

If val is 0

``````0+1-0*2=1
``````

If val is 1

``````1+1-1*2=0
``````

If you want to be short:

``````f = lambda val: 0 if val else 1
``````

Then:

``````>>> f(0)
1
>>> f(1)
0
``````

The most pythonic way would probably be

``````int(not val)
``````

But a shorter way would be

``````-~-val
``````

I have swapped 0s and 1s in a list.

Here’s my list:

``````list1 = [1,0,0,1,0]

list1 = [i^1 for i in list1]
#xor each element is the list

print(list1)
``````

So the outcome is: [0,1,1,0,1]

Just another way:

``````val = ~val + 2
``````

(0,1)[not val]
flips the val from 0 to 1 and vice versa.

After seeing all these simpler answers i thought of adding an abstract one , it’s Pythonic though :

``````val = set(range(0,2)).symmetric_difference(set(range(0 + val, val + 1))).pop()
``````

All we do is return the difference of 2 sets namely [0, 1] and [val] where val is either 0 or 1.

we use symmetric_difference() to create the set [0, 1] – [val] and pop() to assign that value to variable val.

Another option:

``````val = (not val) * 1
``````

Function with mutable argument. Calling the `swaper()` will return different value every time.

``````def swaper(x=[1]):
x[0] ^= 1
return x[0]
``````

``````val = abs(val - 1)
``````

short and simple!

use np.where

ex.

``````np.where(np.array(val)==0,1,0)
``````

this gives 1 where val is 0 and gives 0 where val is anything else, in your case 1

EDIT: val has to be array

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .