Boolean operators produce a single boolean output value from one or more input values. There are three boolean operators in boolean algebra: **AND**, **OR**, and **NOT**. Python uses `and`

, `or`

, and `not`

to implement them. We shall learn about Python’s not operator in this tutorial.

## The **not** operator

It is used to get the negation of a value, i.e. it allows us to invert the truth value of a given boolean expression. This operator can be applied in boolean situations like if statements and while loops. It also functions in non-Boolean settings, enabling you to reverse the variables’ truth values.

The below table shows the outcomes for some input values when the not the operator is applied to them.

Input | Output |

True | False |

False | True |

`not`

is a unary operator which means it takes only one input value. It can be used with any boolean expression or Python object.

## Using not with different data types

## Using not with conditional statements

Let’s see how the not operator in Python works with the different types of conditional statements we have.

### if statement

```
num = 25
if not num%2==0:
print("num is an odd number")
else:
print("num is an even number")
```

**Output:**

```
num is an odd number
```

Here, num%2 i.e. 25%2 equals 1 and not 0. The `if`

statement checks whether num%2==0 is False. Since the condition is satisfied, the output says the number is odd. If it were an even number, the `else`

condition would have been satisfied.

### while loop

```
count = 1
while not count>5:
print(count)
count = count + 1
```

**Output:**

```
1
2
3
4
5
```

The condition count>5 checks if the number of records is greater than 5. The `while`

loop executes till `count`

is less than 5. Once `count`

‘s value becomes 6, the loop will terminate.

## Methods of implementing the **not** boolean operator in Python

### Method 1: Using the ‘not’ keyword

```
var = False
print(not var)
```

**Output:**

```
True
```

```
var = True
print(not var)
```

**Output:**

```
False
```

Above are simple examples of using the `not`

keyword in Python.

### Method 2: Using the ‘~’ operator

‘~’ is called the negation operator.

```
flag = True
print("Flag is ", flag)
print("Flag is ", bool(~flag))
```

**Output:**

```
Flag is True
Flag is False
```

In this example, the `flag`

is set to `True`

at first and its value is printed. In the next line, we first take the negation of `flag`

by writing `~flag`

and we have written `bool(~flag)`

because if the flag was not a boolean at first, then it will be converted into a boolean.

### Method 3: Using the operator module

The **operator** module in Python provides various methods like addition, subtraction, exponentiation, left shift, right shift, etc. One among these many methods is `not_()`

. It returns the negated value of the argument provided to it.

```
import operator
initial_list = [False, True, True, False]
print("Initial list:", initial_list)
negated_list = []
for i in range(0, len(initial_list)):
negated_list.append(operator.not_(initial_list[i]))
print("Negated list:", negated_list)
```

**Output:**

```
Initial list: [False, True, True, False]
Negated list: [True, False, False, True]
```

Here, we have first imported the operator module. Then we created a list of some boolean values. The loop iterates over the ‘initial_list’ and negates each value using the `not_()`

method from the **operator** module and appends it to the ‘negated_list’.

### Method 4: Using the bitwise_not() method from NumPy

Numpy provides a `bitwise_not()`

method to find the negation of a value. It performs bitwise NOT operation on its arguments.

```
import numpy as np
print(np.bitwise_not(True))
print(np.bitwise_not(False))
```

**Output:**

```
False
True
```

The above code uses the `bitwise_not()`

method to negate only a single value. We can also use a NumPy array of elements as shown below.

```
import numpy as np
a = np.array([True, False, False])
a = np.bitwise_not(a)
print(a)
```

**Output:**

```
[False True True]
```

### Method 5: Using the invert() method from NumPy

This method also performs the bitwise NOT operation on arguments passed to it. It can be used on a single element or an array of elements.

```
import numpy as np
print(np.invert(False))
print(np.invert(True))
```

**Output:**

True False

**Another example:**

```
import numpy as np
a = [True, False, False]
a = np.invert(a)
print(a)
```

**Output:**

```
[False True True]
```

### Method 6: Using the logical_not() method from NumPy

This method can also be used for finding the negation of a boolean value. Just like the bitwise_not() and invert() methods, this method can also be applied to both, a single argument or a list of arguments as shown below.

```
import numpy as np
print(np.logical_not(False))
print(np.logical_not(True))
```

**Output:**

```
True
False
```

**Another example:**

```
import numpy as np
a = [True, False, True]
a = np.logical_not(a)
print(a)
```

**Output:**

```
[False True False]
```

## Conclusion

That’s all! We have learnt about the **not** operator and also the different ways in which we can use it in Python.