Introduction

Double star or double asterisk (**) in Python code can mean two different things based on the position in the code. First, if a double asterisk stands in the equation, it is part of it and is considered a Power operator. Otherwise, double-asterisk can occur in function and method argument input, and in such a case, it should be followed by kwargs shortcut (keyword arguments).

Power Operator

What is double start operator in equation?

Double star (or double-asterisk) in mathematical equation is one of the arithmetic operator (like +, -, *, **, /, //, %) in Python programming language. Double stars are also known as Power operator.

What Power Operator does?

For numerical data types Power operator works as an Exponential operator – anything on the right is the power of the left side.

Rather than talking about it, let’s demonstrate the Exponential operator on example:

two = 2
three = 3
# We can read the following notation as two to the power of the three
result = two ** three
# Result is according to the math laws, and it is equal to 2 * 2 * 2
print(result)

# Example of using double asterisk operator.
result_2 = 10 * (4 ** 2) - (2 ** 2) * 20
print(result_2)

Output

8
80

What is the order of arithmetic operators?

Arithmetic operators in Python follow the same precedence rule as in mathematics. The order is as follows: first performs exponential operator, then multiplication and division; as last executed are addition and subtraction, retrospectively.

Arithmetic operators ordered in decreasing order by priority:

() -> ** -> * -> / -> // ->  % -> + -> -

** as variable argument length in functions and methods

Interestingly, in Python, two starts fulfil also a different role. In Python’s function and method definition, the double-asterisk is also known for its role in defining variable argument length. Double asterisk concatenate with kwargs word and form **kwargs. So every time you see it, it means that the method or function it contains has a variable-length argument dictionary in the place of **kwargs occurrence. So when we use **kwargs as a parameter, we don’t need to know how many arguments we will need to pass to a function/method.

Btw. kwargs is not a Python reserved word and can be used in Python code independently.

**kwargs examples

Let’s write a simple function with **kwargs, taking various length arguments and passing them to a function.

def function(**kwargs):
    for key, value in kwargs.items():
        print("key: {} - value: {}".format(key, value))

function(pos1="John", pos2="Thomas", pos3="Paul")

Output

key: pos1 - value: John
key: pos2 - value: Thomas
key: pos3 - value: Paul

And now, let’s use the same function with additional arguments. Then, we will see how the function with **kwargs will accept a different number of arguments:

def function(**kwargs):
    for key, value in kwargs.items():
        print("key: {} - value: {}".format(key, value))

function(pos1="John", pos2="Thomas", pos3="Paul", pos4="Isabella", pos5="Carry", pos6="Angela")

Output

key: pos1 - value: John
key: pos2 - value: Thomas
key: pos3 - value: Paul
key: pos4 - value: Isabella
key: pos5 - value: Carry
key: pos6 - value: Angela

Note: It is a good idea to create functions that accept **kwargs where you expect the number of inputs within the argument list to remain relatively small.

Conclusion

This article has shown two different ways how the double asterisk is used. First, we have seen the order of arithmetic operators in Python and how a double asterisk denotes a mathematical Power operator. The second usage is variable argument length in Python’s functions and class methods. Usage of **kwargs provides us flexibility to use keyword arguments in our program.

Did you find the usage of double stars in Python confusing? Do you have any tricks or know another way how to use double stars in Python? Let us know in the comments below the article. We would like to hear your ideas and stories.

How to use Python split function

The first split function parameter is a separator, character on which the division of string will be happening. If the split function has an empty separator character, whitespace will be used as default splitting character. Let’s look at the example:

s = 'And now something completely different...'
print(s.split())
# ['And', 'now', 'something', 'completely', 'different...']

We can use also custom string as splitting string:

s = 'spam, ham, sausages, spam, sausage - spam, spam with eggs'
print(s.split(", "))
# ['spam', 'ham', 'sausages', 'spam', 'sausage - spam', 'spam with eggs']

What I personally consider the greatest plus of Python split method is actually a possibility to directly assign split string parts into the variable. Here is a nice example:

s = 'spam, ham, eggs'
x, y, z = s.split(", ")
print(x)
# spam
print(y)
# ham
print(z)
# eggs

Splitting the string is opposite of concatenation. If you want to concatenate the strings, check the guide how to concatenate the strings in the best way.

Concatenation with + operator

First way is to use + operator for concatenation:

s  = 'And '
s += 'now '
s += 'something '
s += 'completely '
s += 'different.'
print(s)

Since everything in Python is an object and Strings in Python in immutable, this solution is unoptimized. Every time the + operator is called reference on new object is assigned to variable. It is sufficient to use it for simple programs. For more complex programs requiring building lots of text I would recommend to use less resource requiring approach.

Building strings with .append()

Second option is to use approach for building up string from a list. If you are familiar with Java’s OOP approach, StringBuilder is similar way to build strings in Java.

Idea is simple. First create list of all append-able strings and then use str.join() method to concatenate them all at the end:

l = []
l.append('And')
l.append('now')
l.append('something')
l.append('completely')
l.append('different.')
s = ''.join(l)
print(s)
# And now something completely different.

Difference between string concatenation with + operator and building string over append is in performance. Despite in short text the performance difference is none, in longer text building strings over append will create new string in one go while + operator build string over and over, repetitively.

.append vs. + operator

Here I made a small code to test which operation for concatenating strings is faster:

import time

# append in loop
app_start = int(round(time.time() * 1000))
l = []
for _ in range(0,10000000,1):
    l.append('a')
string = ''.join(l)
app_end = int(round(time.time() * 1000))
print('With append: %s' % (app_end - app_start))

# conc with +
plus_start = int(round(time.time() * 1000))
s = ''
for _ in range(0,10000000,1):
    s += 'a'
plus_end = int(round(time.time() * 1000))
print('With +: %s' % (plus_end - plus_start))

I run the code on my Mac Pro which is mid 2015 configuration. The results are in microseconds:

It is obvious that for small number of rounds there is no difference between .append or + operator. But with increasing complexity (increasing number of rounds) appending strings to list will be slightly faster by nearly quarter.

Using .join()

You can also use strings in join function directly:

s1 = "And now something "
s2 = "completely different."
s = " ".join((s1, s2))
print(s)
# And now something completely different.

Padding

One of the most simplest way is just pad strings into the new string. We can use either the % operator for padding in exact order or use .format() method to define unique keywords and place them in arbitrary order:

s1 = 'And now something'
s2 = 'completely different'

new_s1 = "Sentence: %s %s" % (s1, s2)
print(new_s1)
# Sentence: And now something completely different.

new_s2 = "Sentence: {string2} {string1}".format(string1=s1, string2=s2)
print(new_s2)
# Sentence: completely different And now something.

Using __add__ method

Marvel of Python is its neat variability. Since everything in Python is the object we can use object’s __add__ method for concatenation. Using s1.__add__(s2) is identical with using a+b.

s1='And now something '
s2='completely different.'
s = s1.__add__(s2)
print(s)
# Sentence: And now something completely different.

When you concatenate strings using the + operator, Python will call the __add__ method while on the string on the left side passing the right side string as a parameter. So using this method on simple strings is code overkill.

It make much more sense to use it for concatenation object properties.

class Sentence(object):
  def __init__(self, part):
     self.part = part
  def __add__(self, other):
     total = self.part + ' ' + other.part
     return Sentence(total)

  def __radd__(self, other):
     if other == 0:
       return self
     else:
       return self.__add__(other)

  def __str__(self):
     return "Sentence: %s" % (self.part)

s1 = Sentence('And now')
s2 = Sentence('something completely different.')
print(s1)
# Sentence: And now
print(s2)
# Sentence: something completely different.

s = s1 + s2
print(s)
# Sentence: And now something completely different.

super_s = sum([s, s1, s2])
print(super_s)
# Sentence: And now something completely different. And now something completely different.

As we saw in the previous section there are several ways how to append strings or concatenate them together. You can use literally any provided solution here, it only depends on a purpose and necessary complexity you want to implement in your program.