Formatting Complex Numbers

For a project in one of my classes we have to output numbers up to five decimal places.It is possible that the output will be a complex number and I am unable to figure out how to output a complex number with five decimal places. For floats I know it is just:

print "%0.5f"%variable_name

Is there something similar for complex numbers?

Here is Solutions:

We have many solutions to this problem, But we recommend you to use the first solution because it is tested & true solution that will 100% work for you.

Solution 1

You could do it as is shown below using the str.format() method:

>>> n = 3.4+2.3j
>>> n
>>> '({0.real:.2f} + {0.imag:.2f}i)'.format(n)
'(3.40 + 2.30i)'
>>> '({c.real:.2f} + {c.imag:.2f}i)'.format(c=n)
'(3.40 + 2.30i)'

To make it handle both positive and negative imaginary portions properly, you would need a (even more) complicated formatting operation:

>>> n = 3.4-2.3j
>>> n
>>> '({0:.2f} {1} {2:.2f}i)'.format(n.real, '+-'[n.imag < 0], abs(n.imag))
'(3.40 - 2.30i)'

Update – Easier Way

Although you cannot use f as a presentation type for complex numbers using the string formatting operator %:

n1 = 3.4+2.3j
n2 = 3.4-2.3j

    print('test: %.2f' % n1)
except Exception as exc:
    print('{}: {}'.format(type(exc).__name__, exc))


TypeError: float argument required, not complex

You can however use it with complex numbers via the str.format() method. This isn’t explicitly documented, but is implied by the Format Specification Mini-Language documentation which just says:

'f'  Fixed point. Displays the number as a fixed-point number. The default precision is 6.

. . .so it’s easy to overlook.
In concrete terms, the following works in both Python 2.7.14 and 3.4.6:

print('n1: {:.2f}'.format(n1))
print('n2: {:.2f}'.format(n2))


n1: 3.10+4.20j
n2: 3.10-4.20j

This doesn’t give you quite the control the code in my original answer does, but it’s certainly much more concise (and handles both positive and negative imaginary parts automatically).

Update 2 – f-strings

Formatted string literals (aka f-strings) were added in Python 3.6, which means it could also be done like this in that version or later:

print(f'n1: {n1:.2f}')  # -> n1: 3.40+2.30j
print(f'n2: {n2:.3f}')  # -> n2: 3.400-2.300j

In Python 3.8.0, support for an = specifier was added to f-strings, allowing you to write:

print(f'{n1=:.2f}')  # -> n1=3.40+2.30j
print(f'{n2=:.3f}')  # -> n2=3.400-2.300j

Solution 2

Neither String Formatting Operations – i.e. the modulo (%) operator) –
nor the newer str.format() Format String Syntax support complex types.
However it is possible to call the __format__ method of all built in numeric types directly.
Here is an example:

>>> i = -3 # int
>>> l = -33L # long (only Python 2.X)
>>> f = -10./3 # float
>>> c = - 1./9 - 2.j/9 # complex
>>> [ x.__format__('.3f') for x in (i, l, f, c)]
['-3.000', '-33.000', '-3.333', '-0.111-0.222j']

Note, that this works well with negative imaginary parts too.

Solution 3

For questions like this, the Python documentation should be your first stop. Specifically, have a look at the section on string formatting. It lists all the string format codes; there isn’t one for complex numbers.

What you can do is format the real and imaginary parts of the number separately, using x.real and x.imag, and print it out in a + bi form.

Solution 4

>>> n = 3.4 + 2.3j
>>> print '%05f %05fi' % (n.real, n.imag)
3.400000 2.300000i

Solution 5

As of Python 2.6 you can define how objects of your own classes respond to format strings. So, you can define a subclass of complex that can be formatted. Here’s an example:

>>> class Complex_formatted(complex):
...     def __format__(self, fmt):
...         cfmt = "({:" + fmt + "}{:+" + fmt + "}j)"
...         return cfmt.format(self.real, self.imag)
>>> z1 = Complex_formatted(.123456789 + 123.456789j)
>>> z2 = Complex_formatted(.123456789 - 123.456789j)
>>> "My complex numbers are {:0.5f} and {:0.5f}.".format(z1, z2)
'My complex numbers are (0.12346+123.45679j) and (0.12346-123.45679j).'
>>> "My complex numbers are {:0.6f} and {:0.6f}.".format(z1, z2)
'My complex numbers are (0.123457+123.456789j) and (0.123457-123.456789j).'

Objects of this class behave exactly like complex numbers except they take more space and operate more slowly; reader beware.

Solution 6

Check this out:

np.set_printoptions(precision=2)  # Rounds up to 2 decimals all float expressions

I’ve successfully printed my complexfloat’s expressions:

# Show poles and zeros
print( "zeros = ", zeros_H , "\n")
print( "poles = ", poles_H )

out before:

zeros =  [-0.8       +0.6j -0.8       -0.6j -0.66666667+0.j ] 

poles =  [-0.81542318+0.60991027j -0.81542318-0.60991027j -0.8358203 +0.j        ]

out after:

zeros =  [-0.8 +0.6j -0.8 -0.6j -0.67+0.j ] 

poles =  [-0.82+0.61j -0.82-0.61j -0.84+0.j  ]

Note: Use and implement solution 1 because this method fully tested our system.
Thank you 🙂

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

Leave a Reply