# 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
(3.4+2.3j)
>>> '({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
(3.4-2.3j)
>>> '({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

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

Output:

``````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))
``````

Output:

``````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 stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0