In this tutorial, we will learn about **plus (+) operator in Python**. The plus operator + is provided by Python to enable the combination of two objects. The interpretation of the addition operation relies on the data types of the operands. It should be noted that arithmetic addition is performed when two integers are added, while list concatenation occurs when two lists are combined. The determination of the precise result yielded by the addition operator is specified within the add() magic method of the respective data types.

### Example:

```
# Plus Operator Example
# Adding two integers
num1 = 10
num2 = 5
result = num1 + num2
print("Addition of two integers:", result)
# Adding two floats
float1 = 3.14
float2 = 2.5
result = float1 + float2
print("Addition of two floats:", result)
# Concatenating two strings
str1 = "Hello, "
str2 = "World!"
result = str1 + str2
print("Concatenation of two strings:", result)
# Combining two lists
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print("Combining two lists:", result)
```

### Output:

```
Addition of two integers: 15
Addition of two floats: 5.64
Concatenation of two strings: Hello, World!
Combining two lists: [1, 2, 3, 4, 5, 6]
```

In this program, the plus operator is used to perform addition between two integers, addition between two floats, concatenation of two strings, and combining two lists. The outputs show the results of each operation.

## + operator in Python

In Python, it is possible to pass the **plus operator (+)** as an argument to a function or method. This allows for dynamic computation and flexibility in programming. Bypassing the plus operator as an argument, you can define custom behavior for different data types or perform specific operations based on certain conditions. It enables you to abstract the addition logic and reuse it in various contexts.

```
def custom_addition(a, b, operator):
return operator(a, b)
# Define custom addition functions
def arithmetic_addition(a, b):
return a + b
def string_concatenation(a, b):
return a + b
def list_combination(a, b):
return a + b
# Example usage
num1 = 10
num2 = 5
result = custom_addition(num1, num2, arithmetic_addition)
print("Arithmetic addition:", result)
str1 = "Hello, "
str2 = "World!"
result = custom_addition(str1, str2, string_concatenation)
print("String concatenation:", result)
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = custom_addition(list1, list2, list_combination)
print("List combination:", result)
```

### Output:

```
Arithmetic addition: 15
String concatenation: Hello, World!
List combination: [1, 2, 3, 4, 5, 6]
```

In this program, we define a `custom_addition`

a function that takes two arguments (a and b) and an additional argument operator. The operator the parameter represents a function that performs the addition operation.

We also define three custom addition functions (`arithmetic_addition`

, `string_concatenation`

, and `list_combination`

) that correspond to different data types. These functions are then passed as arguments to the `custom_addition`

function.

The program demonstrates the flexibility of passing the plus operator as an argument by performing arithmetic addition, string concatenation, and list combination based on the provided custom functions.

## Plus sign and operator in Python

The sign “+” in Python serves as both a mathematical operator and a concatenation operator, depending on the context in which it is used.

As a mathematical operator, the + sign performs addition between two numeric values, such as integers or floating-point numbers. It adds the values together and returns the sum.

As a concatenation operator, the plus sign combines two strings or sequences together, creating a new string or sequence that contains the elements of both. This allows for the joining of text or the merging of lists.

```
# Mathematical addition
num1 = 10
num2 = 5
result = num1 + num2
print("Mathematical addition:", result)
# String concatenation
str1 = "Hello, "
str2 = "World!"
result = str1 + str2
print("String concatenation:", result)
# List concatenation
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print("List concatenation:", result)
```

### Output :

```
Mathematical addition: 15
String concatenation: Hello, World!
List concatenation: [1, 2, 3, 4, 5, 6]
```

In this program, the plus sign is used for mathematical addition between two integers, resulting in the sum of 10 and 5. It is also used for string concatenation, combining the strings “Hello, ” and “World!” to form the string “Hello, World!”. Lastly, it performs list concatenation by joining the elements of two lists, producing a new list [1, 2, 3, 4, 5, 6].