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?

回答1:

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.

回答2:

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

回答3:

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.

回答4:

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

回答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.