Coder Legion - Recent posts tagged operators

Building a Kubernetes Operator in Go with Kube-Shift

Sun, 20 Jul 2025 07:50:26 +0000

Kubernetes has become the de-facto standard for container orchestration. As its adoption grows, so does the need for extending its capabilities to manage complex, stateful applications. This is where Kubernetes Operators come in. In this article, we'll explore how to build a custom Kubernetes Operator from scratch using Go and the controller-runtime library. We'll use kube-shift, a custom operator for database schema migrations, as a real-world example to guide us through the process.

The "Why": What Problem Do Operators Solve?

Before we dive into the code, let's understand the problem operators solve. Managing applications on Kubernetes often involves more than just deploying a set of pods. Many applications require complex lifecycle management, including installation, upgrades, and handling failures. Operators automate these tasks by extending the Kubernetes API with Custom Resource Definitions (CRDs) and a custom controller to manage them.

The kube-shift project is a perfect example. It introduces a DatabaseMigration resource to Kubernetes, allowing you to manage database schema changes as part of your deployment process, just like any other Kubernetes resource.

Setting the Stage: Project Scaffolding with Kubebuilder

The kube-shift operator, like many Go-based operators, is built using the Kubebuilder framework. Kubebuilder provides a set of tools to quickly scaffold a new operator project, including the boilerplate for CRDs, controllers, and other necessary components.

The entry point of our operator is cmd/main.go This file is responsible for setting up and running the controller manager.

// cmd/main.go
package main
 
import (
// ... imports
"github.com/mohit-nagaraj/kube-shift/api/v1alpha1"
"github.com/mohit-nagaraj/kube-shift/internal/controller"
// ...
)
 
func main() {
// ... flag parsing and setup

mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{
// ... options
})
if err != nil {
setupLog.Error(err, "unable to start manager")
os.Exit(1)
}
 
if err = (&controller.DatabaseMigrationReconciler{
Client: mgr.GetClient(),
Scheme: mgr.GetScheme(),
}).SetupWithManager(mgr); err != nil {
setupLog.Error(err, "unable to create controller", "controller", "DatabaseMigration")
os.Exit(1)
}
 
// ...
}

Here, we create a new manager and register our DatabaseMigrationReconciler with it. The manager is responsible for running the controller and managing its lifecycle.

Defining Our Custom Resource: The DatabaseMigration CRD

The first step in creating our operator is to define the custom resource it will manage. This is done in api/v1alpha1/databasemigration_types.go. This file defines the Go types that represent our DatabaseMigration CRD.

// api/v1alpha1/databasemigration_types.go
package v1alpha1
 
import (
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)
 
// DatabaseMigrationSpec defines the desired state of DatabaseMigration
type DatabaseMigrationSpec struct {
Database  DatabaseConfig  `json:"database"`
Migration MigrationConfig `json:"migration"`
}
 
// DatabaseMigrationStatus defines the observed state of DatabaseMigration
type DatabaseMigrationStatus struct {
Phase   MigrationPhase `json:"phase,omitempty"`
Message string         `json:"message,omitempty"`
}
 
// +kubebuilder:object:root=true
// +kubebuilder:subresource:status
 
// DatabaseMigration is the Schema for the databasemigrations API
type DatabaseMigration struct {
metav1.TypeMeta   `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
 
Spec   DatabaseMigrationSpec   `json:"spec,omitempty"`
Status DatabaseMigrationStatus `json:"status,omitempty"`
}

The DatabaseMigration struct embeds metav1.TypeMeta and metav1.ObjectMeta, which are common to all Kubernetes objects. The Spec field defines the desired state of our resource, while the Status field represents its current state.

The Heart of the Operator: The Controller and Reconciliation Loop

With our CRD defined, we need a controller to act on it. The controller's logic is implemented in internal/controller/databasemigration_controller.go. The core of the controller is the Reconcile function. This function is called every time a DatabaseMigration resource is created, updated, or deleted.

// internal/controller/databasemigration_controller.go
 
// DatabaseMigrationReconciler reconciles a DatabaseMigration object
type DatabaseMigrationReconciler struct {
client.Client
Scheme *runtime.Scheme
Log    logr.Logger
// ... other fields
}
 
// +kubebuilder:rbac:groups=database.mohitnagaraj.in,resources=databasemigrations,verbs=get;list;watch;create;update;patch;delete
// ... other rbac markers
 
func (r *DatabaseMigrationReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
log := r.Log.WithValues("databasemigration", req.NamespacedName)
 
// your logic here
 
return ctrl.Result{}, nil
}

The Reconcile function receives the name and namespace of the DatabaseMigration resource that triggered the event. It's the reconciler's job to fetch the resource and take the necessary actions to bring the system to the desired state defined in the resource's Spec. This could involve creating jobs, pods, or other resources to perform the database migration.

Advanced Reconciliation: Beyond the Basics

A robust operator does more than just create resources. kube-shift demonstrates several advanced concepts:

Status Updates: The controller updates the Status field of the DatabaseMigration resource to reflect the current state of the migration. This provides valuable feedback to users.
Finalizers: To ensure graceful cleanup, kube-shift uses a finalizer. The DatabaseMigrationFinalizer is added to the resource on creation. This prevents the resource from being deleted until the controller has performed any necessary cleanup tasks.
Leader Election: In a high-availability setup, you might run multiple instances of your operator. Leader election ensures that only one instance is active at a time, preventing conflicts. This is configured in cmd/main.go.

Testing Your Operator

Testing is crucial for any production-grade software. kube-shift includes both unit and integration tests.

Unit Tests: These tests focus on individual components of the operator in isolation.
Integration Tests: The project uses the envtest package to run integration tests against a real Kubernetes API server. You can see this in internal/controller/suite_test.go, which sets up a test environment for the controller tests.

Conclusion

Building a Kubernetes Operator is a powerful way to extend Kubernetes and automate complex application management tasks. By leveraging tools like Kubebuilder and controller-runtime, you can create robust, production-ready operators. The kube-shift project is an excellent example of how to apply these concepts to solve a real-world problem.

To learn more, I encourage you to explore the kube-shift repository on GitHub. You'll find the complete source code, along with more details on how to build, deploy, and use the operator. Happy coding!

Exploring Python Operators: Beyond the Basics

Sat, 22 Jun 2024 12:48:45 +0000

A. Introduction

This article is part 2 of the Basic Operators which examines Logical, Bitwise, Membership and Identity operators. This is a continuation of Part 1 which discusses Arithmetic, Comparison and Assignment operators.

Logical operators are used for evaluating conditions in control flow statements, Bitwise operators manipulate individual bits of integers, Membership operators check for the existence of a value within a sequence, and Identity operators check object identity in memory.

B. Logical Operators

These Logical operators evaluate the left and right operands which will result to either a true or false values.

1. and

The "and" operator checks if both operands are true, and if it is, then the result will be true, otherwise false.

>>> a = 100
>>> b = 20
>>> a == 100 and b == 20
True

First it evaluates if a is equal to 100 the result is True. Second it evaluates if b is equal to 20 the result is also True. Since both operands are True the final result is True. We can say that True and True is True.

Here is another example where the second operand is false.

>>> a = 100
>>> b = 20
>>> a == 100 and b < 20
False

The second operand checks if b is below 20, the answer is False because b which is 20 is not below 20. So True and False results to a False result.

Another example where the first operand is False and the second operand is True.

>>> a = 100
>>> b = 20
>>> a > 100 and b >= 20
False

The first operand evaluates to False because a which is 100 is not greater than 100. While in the second operand, it evaluates to True because b which is 20 is equal or greater than 20. So the final evaluation is False and True will result in False because both are not True.

Our last example demonstrates a scenario where both operands are false.

>>> a = 100
>>> b = 20
>>> a < 100 and b > 20
False
>>> a < 100
False
>>> b > 20
False
>>> False and False
False
>>>

So False and False will result in false.

In summary this is the truth table for and operator.

A	B	A and B
False	False	False
False	True	False
True	False	False
True	True	True

2. or

The or operator evaluates to true if one or both of the operands are true, otherwise false.

Let's see an example where the first operand is true and the second is false.

>>> a = 100
>>> b = 20
>>> a == 100 or b > 20
True
>>> a == 100
True
>>> b > 20
False
>>> True or False
True

The final result is True because one of the operand is True.

Here is an example scenario where the first operand is false and the second operand is true.

>>> a = 100
>>> b = 20
>>> a < 100 or b == 20
True
>>> a < 100
False
>>> b == 20
True
>>> False or True
True

The next example shows that both operands are false.

>>> a = 100
>>> b = 20
>>> a < 100 or b > 20
False
>>> a < 100
False
>>> b > 20
False
>>> False or False
False

So when both are False, the result is False.

Our last example examines what happens if both are true.

>>> a = 100
>>> b = 20
>>> a >= 100
True
>>> b <= 20
True
>>> a >= 100
True
>>> b <= 20
True
>>> True or True
True

So the final result is True if both are True.

Here is the truth table with or operator.

A	B	A or B
False	False	False
False	True	True
True	False	True
True	True	True

3. not

The not operator negates the given value. If the value is True, it converts it to False. And if the value is False, it converts it to True.

>>> a = True
>>> not a
False
>>> b = False
>>> not b
True

Tip: In Logical operators, it always results to either True or False values.

C. Bitwise Operators

Bitwise refers to the operations to be done on the binary bits (0 and 1). There are 6 bitwise operators that we are going to discuss. These are the "&" (and), "|" (or), "^" (xor), "~" (not), "<<" (left shift) and ">>" (right shift).

These operators are used to operate on the operands of the binary numbers. A binary number is a representation which uses only two symbols: 0 and 1. Each digit in a binary number is called a "bit," which stands for binary digit. An example of binary number is "0101". That is a 4-bit binary number.

Convert a decimal number to binary

Consider the decimal number 4, what is its binary number equivalent? Here is a manual procedure to convert it to binary.

Divide the number by 2 and record the quotient and remainder.
If quotient is not zero, divide it again by 2 and record the quotient and remainder.
If quotient is zero record the remainder and stop the division. However if it is not zero go to step 2.

Get all the remainders starting from the last step to form the binary number with 1's and 0's.

Example

1. 4 / 2 = 2 remainder 0
2. 2 / 2 = 1 remainder 0
3. 1 / 2 = 0 remainder 1

Get all the remainder starting from step 3 to step 1.

`100`

Convert a binary to decimal

Let's convert a binary "100" to decimal number.

Starting from leftmost bit we will multiply the digit by its power of two.

0 x 2^0 = 0
0 x 2^1 = 0
1 x 2^2 = 4

Then sum the results which is 4 or 0 + 0 + 4.

1. &

The "and" operator & operates on the operands bit by bit. If both operands are 1, the result is 1, otherwise the result is 0. Let's have an example.

Here is a table with decimal integer with equivalent 4-digit binary number.

0 = `0000`
1 = `0001`
2 = `0010`
3 = `0011`
4 = `0100`
5 = `0101`
6 = `0110`
7 = `0111`
8 = `1000`
9 = `1001`

Let's solve this, calculate the result if an & operator is applied to integers 3 and 5.

3 = `0011`
5 = `0101`

    0011
&   0101
========
    0001

In the first column it is `0 & 0` which is 0.
In the second column it is `0 & 1` which is 0.
In the third column it is `1 & 0` which is 0.
In the fourth column it is `1 & 1` which is 1.

So, the final result is 0001. We can change that to decimal with the following steps.

decimal = 1 x 2^0 + 0 x 2^1 + 0 x 2^2 + 0 x 2^3
decimal = 1 + 0 + 0 + 0
decimal = 1

So 3 & 5 is equal to 1.

The truth table for Bitwise operations.

A	B	A & B
0	0	0
0	1	0
1	0	0
1	1	1

2. |

The "or" operator | operates bit by bit according to the following truth table.

A	B	A \| B
0	0	0
0	1	1
1	0	1
1	1	1

Example

result = 7 | 4

`0111`
`0100`
=====
`0111`

operate vertically

0 | 0 = 0
1 | 1 = 1
1 | 0 = 1
1 | 0 = 1

decimal value for `0111`
result = 1 x 2^0 + 1 x 2^1 + 1 x 2^2 + 0 x 2^3
result = 1 + 2 + 4 + 0
result = 7

>>> 7 | 4
7
>>>

3. ^

The "xor" operator ^ performs an exclusive "or" operation on both operands bit by bit. If two corresponding bits are different, the result is 1. If two corresponding bits are the same, the result is 0.

This is the truth table for `xor`.

A	B	A xor B
0	0	0
0	1	1
1	0	1
1	1	0

result = 7 ^ 4

`0111`
`0100`
=====
`0011`

decimal value for `0011`
result = 1 x 2^0 + 1 x 2^1 + 0 x 2^2 + 0 x 2^3
result = 1 + 2 + 0 + 0
result = 3

>>> 7 ^ 4
3
>>>

4. ~

The "not" operator ~ executes a negation operation on its operand bit by bit. If bit is 0, it sets it to 1. And if it is 1, it sets it to 0. It is like a switch on/off.

Example with a 4-bit integer 7.

result = ~7

~ `0111`
=======
   1000

decimal value
result = 0 x 2^0 + 0 x 2^1 + 0 x 2^2 + 1 x 2^3
result = 0 + 0 + 0 + 8
result = 8

5. <<</h3> The "left shift" operator `<<</code> is used to shift to the left, the bits of a binary number by a given number of positions. Example. n = 7 8-bit binary is 00000111. n The right-bit is supplied with two 0 bits and the existing bits are shifted to the left by two positions. 6. >>`

The "right shift" operator >> is used to shift to the right, the bits of a binary number by a given number of positions.

Example

n = 7
4-bit binary is 0111

shift the bit 2 position to the right.
n >> 2
result = 0001

In decimal:

result = 1 x 2^0 + 0 x 2^1 + 0 x 2^2 + 0 x 2^3
result = 1 + 0 + 0 + 0
result = 1

Note: In Bitwise operations, the computation is performed bit by bit.

D. Membership Operators

Membership operators in and not in are used to test whether a value is found or not within a sequence. This sequence can be a string, dictionary, list or even a tuple.

1. in

The in operator checks if an item is in a sequence. If so it will return a boolean True otherwise False.

String example

>>> a = 'Paris'
>>> b = 'The 2024 summer olympics will be held in Paris.'
>>> a in b
True

Dictionary example

>>> cars = {'Ford': ['blind spot monitor', 'hill assist'], 'BMW': ['climate control', 'mild hybrid']}
>>> 'Ford' in cars
True

List example

>>> a = 45
>>> b = [1, 58, 69, 45, 12, 100]
>>> a in b
True
>>> 'Toyota' in cars
False

Tuple example

>>> countries = ('USA', 'China', 'France', 'Australia')
>>> 'USA' in countries
True

2. not in

The not in operator is the opposite of in. It checks if item is in a sequence and if so, it returns True if not it returns False.

List example.

>>> a = [2, 8, 4, 9]
>>> 5 not in a
True

String example.

>>> a = ['basketball', 'cricket', 'soccer']
>>> 'baseball' not in a
True

Tuple example.

>>> a = (8, 9, 1, 3)
>>> 8 not in a
False

E. Identity Operators

The Identity is and is not operators are used to check if two variables refer to the same object in memory. The is operator returns True if the memory addresses of the two variables are the same, otherwise it returns False. The is not operator is the negatiion is.

1. is

The is operator checks if memory addresses of two operands are the same. If so it returns True otherwise False.

>>> a = 50
>>> b = 100
>>> a is b
False

Let's check the address of a and b.

>>> id(a)
140717562022216
>>> id(b)
140717562023816

Since the address in memory is different, the result is False.

2. is not

The is not operator checks if memory addresses of two operands are different. If so it returns True otherwise False.

>>> a = 'basketball'
>>> b = 'soccer'
>>> a is not b
True

The result is True because the addresses of a and b are different.

FAQ 1. How to get the memory address of an object for `is` and `is not` operators?
Answer: Use the id(object) function.

F. Summary

Logical operators (and, or, not) evaluate operands to produce true or false outcomes. The "and" results in true only if both are true, "or" is true if either operand is true.

Bitwise operators work on binary bits. Examples include "and" (&), "or" (|), "xor" (^), "not" (~), "left shift" (<), and "right shift" (>>). They manipulate binary representations of numbers.

Membership operators (in, not in) determine if a value is within a sequence (e.g., string, list, tuple). 'in' returns true if found, 'not in' returns true if not found.

Identity operators (is, is not) check if variables refer to the same memory location. 'is' returns true if they do, 'is not' returns true if they don't.

It would be interesting to study further especially on operator precedence.

For further reading have a look on Python's Syntax which outlines the fundamental grammar of the language. And Python variables and data types which introduces how to use variables and what data types are.

Basic operators in Python

Sun, 19 May 2024 10:05:23 +0000

A. Introduction

Operators, ranging from a simple addition to a more complex operations like bitwise and beyond, serve as indispensable tools in the hands of the programmers to manipulate data and achieve desired outcomes dictated by the code's objectives. Understanding the specific applications of each operator is crucial to build software that are not only functional but also efficient. Also mastering Python scripting requires a solid understanding of the basics.

Part 1 covers Arithmetic, Comparison and Assignment operators. Part 2 which is in a different article covers Logical, Bitwise, Membership and Identity operators.

B. Arithmetic Operators

Arithmetic operators are used to perform basic arithmetic operations on numerical values.

1. Addition (+)

The operator symbol + is used to get the total or sum from the given operands.

I will be using REPL most of the time to show some examples. REPL stands for Read Evaluate Print Loop. Open your terminal or powershell for windows and type Python. You need to install Python first.

>>> a = 10 + 5
>>> a
15
>>>

The variable a is the sum, the 10 and 5 are the operands.

2. Subtraction (-)

In the subtraction operation we use the subtraction operator with symbol -. The result is the difference, the first operand is called the minuend and the second operand is called the subtrahend.

>>> a = 100
>>> b = 50
>>> c = a - b
>>> c
50
>>>

The c is the difference, a is the minuend, and b is the subtrahend.

3. Multiplication (*)

The result of the multiplication of operands is called a product.

>>> a = 4
>>> b = 2
>>> c = a * b
>>> c
8
>>>

c is called the product, a and b are the operands also called the factors.

4. Division (/)

The result of the division operation is called a quotient. The dividend is the numerator or the number to be divided and the divisor is the denominator or the number that divides the dividend.

>>> a = 100  # dividend
>>> b = 2  # divisor
>>> c = a / 2  # quotient
>>> c
50.0
>>>

5. Floor Division (//)

It is a division but rounds the result off to a whole number.

>>> a = 100
>>> b = 3
>>> c = a // b
>>> c
33
>>>

6. Exponentiation (**)

Exponentiation is an operation that involves raising a base number to a certain number called an exponent. It just multiplies the base n times where n is the exponent.

>>> a = 2  # base
>>> b = 2  # exponent
>>> c = a ** b
>>> c
4
>>>

It is similar to 2*2 or multiplying the two twice which is 4.

7. Modulo (%)

The modulo operator is used to calculate the balance or remainder after performing a division.

Integer modulo operation.

>>> a = 5
>>> b = 2
>>> c = a % b
>>> c
1
>>>

If we divide 5 by 2 the answer is 2 with some extra because 2 times 2 is 4. Now 5 - 4 equals 1, that 1 is called the remainder or balance.

Example with zero remainder.

>>> a = 10
>>> b = 5
>>> c = a % b
>>> c
0
>>>

Since 10 is divisible by 5 or no excess number, the remainder is zero.

Float modulo operation.

>>> a = 6.5
>>> b = 4.3
>>> c = a % b
>>> c
2.2
>>>

Note: The result of addition is a sum, the result of subtraction is a difference, the result of multiplication is a product and the result of division is a quotient.

C. Comparison Operators

Comparison operators are used to compare two operands which results to either True or False value.

Here is a summary of these operators.

Operation	Meaning
<</td>	strictly less than
<=</td>	less than or equal
>	strictly greater than
>=	greater than or equal
=	equal
!=	not equal

1. Equal to (==)

The operator symbol == is used to compare if the two operands are equal.

>>> a = 75
>>> b = 75
>>> c = a == b
>>> c
True
>>> a = 'tuesday'
>>> b = 'wednesday'
>>> c = a == b
>>> c
False
>>>

The variables a and b are called operands.

Here is an example script.

age.py

romeo_age = 36
lando_age = 32

if romeo_age == lando_age:
    print('Romeo and Lando do have the same age.')
else:
    print('Romeo and Lando do not have the same age.')

Run

python age.py

output

print('Romeo and Lando do have the same age.')

2. Not equal to (!=)

The operator != means not equal. It compares if two operands are not equal. If it is not equal the result is True otherwise the result is False.

>>> a = 45
>>> b = 50
>>> c = a != b
>>> c
True
>>>

Since 45 is not equal to 50 the result of the operation is True.

Here is another example comparing two strings or str.

>>> a = 'diamond'
>>> b = 'Diamond'
>>> c = a != b
>>> c
True
>>>

Although the meaning of variables a and b are the same (diamond) they are not equal. This is because Python follows the rule of case sensitivity. In other words a lower case is different from upper case. D is the upper case and d is the lower case.

3. Greater than (>)

The greater than operator with symbol > allows us to know if the value in the left-hand side is greater than the value in the right-hand side. If it is, it would return True otherwise False.

>>> a = 500
>>> b = 450
>>> c = a > b
>>> c
True
>>>

In a > b, the left-hand side is a and the right-hand side is b.

Since 500 is more than 450, the result is True.

>>> a = 1.25
>>> b = 1.26
>>> c = a > b
>>> c
False
>>>

The value 1.25 is below 1.26 that is why the result of the operation is False.

4. Less than (<)</h3> The less than operator with symbol "<" is used to check if the value in the left-hand side is below the value in the right-hand side. `>>> a = 36 >>> b = 45 >>> c = a < b >>> c True >>>` The value of the variable "a" is 36 while the value of the variable "b" is 45. The result is True because 36 is below 45. 5. Greater than or equal to (>=)

The greater than or equal to operator with symbol >= compares if the operand in the left is greater than or equal to the operand in the right. If so the result is a True otherwise it is False.

>>> 100 >= 50
True
>>> 50 >= 75
False
>>> 25 >= 25
True
>>>

6. Less than or equal to (<=)</h3> The comparison operator with symbol `<=</code> checks if the operand in the left is less than or equal to the operand in the right. >>> 50 >= 75 False >>> 25 >= 25 True >>> 12 <= 13 True >>> 14 <= 10 False >>> 8 <= 8 True >>> Tip: In comparison operators, the result is always True or False. D. Assignment Operators These operators primarily assign the value in the right side to the variable in the left side based on the operator used such as =, += and more. 1. Simple assignment (=)`

The equal symbol = assigns the value in the right side to the variable in the left side.

>>> a = 45
>>> a
45
>>>

2. Addition assignment (+=)

The operator += is a combination of arithmetic operator + and assignment operator =. It adds the value in the right side to the existing value in the left side.

>>> a = 10
>>> a += 4
>>> a
14
>>>

That is the same as:

>>> a = 10
>>> a = a + 4
>>> a
14
>>>

3. Subtraction assignment (-=)

This is similar to item 2 except that the arithmetic operation is subtraction.

>>> a = 10
>>> a -= 4
>>> a
6
>>>

4. Multiplication assignment (*=)

The assignment operator *= is a combination of multiplication and assignment.

>>> a = 2
>>> a *= 2
>>> a
4
>>>

This is similar to:

>>> a = 2
>>> a = a * 2
>>> a
4
>>>

5. Division assignment (/=)

The assignment operator /= is a combination of division and assignment.

>>> a = 100
>>> a /= 2
>>> a
50.0
>>>

It is similar to:

>>> a = 100
>>> a = a / 2
>>> a
50.0
>>>

6. Modulus assignment (%=)

The modulo operator % is used to get the remainder. Together with assignment = operator, they are used to assign the remainder in the left side by taking the remainder between the left side value and right side value.

>>> a = 100
>>> a %= 3
>>> a
1
>>>

This is similar to:

>>> a = 100
>>> a = 100 % 3
>>> a
1
>>>

7. Exponentiation assignment (**=)

The **= operator uses the value in the left side as a base and raises to the power by the value in the right side then assigns the result to the variable in the left side.

>>> a = 2
>>> a **= 4
>>> a
16
>>>

This is the same as:

>>> a = 2
>>> a = 2 ** 4
>>> a
16
>>>

The 2**4 is just 2*2*2*2 which is equal to 16. Also the 2**4 is just 2^4 or 2 raised to power 4.

8. Floor division assignment (//=)

It is a combination of floor division and assignment operations. It takes the number in the left side and applies a floor division with the number in the right side and assigns it back to the left side. Floor division is just a division where the remainder is disregarded.

>>> a = 10
>>> a //= 2
>>> a
5

This is similar to 10//2 where the answer is 5 and then assign the 5 back to variable a. Note there is no remainder because 10 divided by 2 is perfectly 5.

Consider another example with remainder.

>>> a = 3
>>> a //= 2
>>> a
1

The first step is to divide 3 by 2 and the answer is 1 with a remainder of 1.

3 / 2 = 1 remainder 1

value = 2 * 1
remainder = 3 - value
remainder = 3 - 2
remainder = 1

In floor division // we ignore the remainder so the final answer is 1.

FAQ 1. What is REPL??
Answer: REPL stands for Read Evaluate Print Loop. It is used to test the code interactively. The user inputs the code and Python will READ, EVALUATE and PRINT the results. Install Python, open terminal and type Python to start the REPL.

2. What happens to the remainder in floor division?
Answer: The remainder is discarded or not used.

E. Summary

Arithmetic operators such as `+, -, *, /, //, **, and %` are used for basic operations like addition, subtraction, multiplication, division, floor division, exponentiation, and modulo respectively.

Comparison operators such as `<, <=, >, >=, ==, !=' are used to compare operands that may yield True or False results.

Assignment operators such as `=, +=, -=, *=, /=, %=, **=, and //=` are used to assign values to variables. They allow for direct modification of variables by performing arithmetic or other operations on them.

It is important for a programmer to learn this basic operators as a foundation to learn advanced topics such as reading files in directory. You should also learn Python syntax, which helps in avoiding errors in your code.

Coder Legion - Recent posts tagged operators

Building a Kubernetes Operator in Go with Kube-Shift

The "Why": What Problem Do Operators Solve?

Setting the Stage: Project Scaffolding with Kubebuilder

Defining Our Custom Resource: The DatabaseMigration CRD

The Heart of the Operator: The Controller and Reconciliation Loop

Advanced Reconciliation: Beyond the Basics

Testing Your Operator

Conclusion

Exploring Python Operators: Beyond the Basics

A. Introduction

B. Logical Operators

1. and

2. or

3. not

C. Bitwise Operators

1. &

2. |

3. ^

4. ~

5. <<</h3> The "left shift" operator <<</code> is used to shift to the left, the bits of a binary number by a given number of positions. Example. n = 7 8-bit binary is 00000111. n The right-bit is supplied with two 0 bits and the existing bits are shifted to the left by two positions. 6. >>

D. Membership Operators

1. in

2. not in

E. Identity Operators

1. is

2. is not

F. Summary

Basic operators in Python

A. Introduction

B. Arithmetic Operators

1. Addition (+)

2. Subtraction (-)

3. Multiplication (*)

4. Division (/)

5. Floor Division (//)

6. Exponentiation (**)

7. Modulo (%)

C. Comparison Operators

1. Equal to (==)

2. Not equal to (!=)

3. Greater than (>)

2. Addition assignment (+=)

3. Subtraction assignment (-=)

4. Multiplication assignment (*=)

5. Division assignment (/=)

6. Modulus assignment (%=)

7. Exponentiation assignment (**=)

8. Floor division assignment (//=)

E. Summary

5. <<</h3> The "left shift" operator `<<</code> is used to shift to the left, the bits of a binary number by a given number of positions. Example. n = 7 8-bit binary is 00000111. n The right-bit is supplied with two 0 bits and the existing bits are shifted to the left by two positions. 6. >>`