Hence have tagged both python and pyspark. ... Save this answer. ... Show activity on this post. You can not add a % to the float and keep it as a float. You either have to send each as strings (format the number as a string with the '%'), ... Or send as is. You could also just send as a float where 1.0 = 100%, .1 = 10% etc, however that is still not adding the % symbol. ... Sign up to request clarification or add additional context in ... More on stackoverflow.com

A float is a floating point number which is a computers representation of a real number (where an integer can only hold whole numbers, real numbers can also be decimals etc). All the float function does is convert what you give it into a floating point number. e.g float(10) will return 10.0 float("10") will also return 10.0 float("10.5") will return 10.5 More on reddit.com

You should look into pyformat when you only want to play around with the string representation.

>>> cash = 13.14
>>> '${}'.format(cash)
'$13.14'
>>> cash = 3.4
>>> '${:.2f}'.format(cash)
'$3.40'
>>> values = [1.2, 65.32, 15.2345]
>>> template = 'Stuff costs ${:.2f}.'
>>> for value in values:
        print(template.format(value))


Stuff costs $1.20.
Stuff costs $65.32.
Stuff costs $15.23.

You could also play around with object oriantation and manipulate the specific string manipulation:

>>> class Dollar:
        def __init__(self, value):
	        self.value = value
        def __add__(self, other):
	        return Dollar(self.value + other.value)
        def __sub__(self, other):
	        return Dollar(self.value - other.value)
        def __repr__(self):
	        return 'Dollar({})'.format(self.value)
        def __str__(self):
	        return '${:.2f}'.format(self.value)


>>> d1 = Dollar(1.2)
>>> d2 = Dollar(4.63)
>>> d1
Dollar(1.2)
>>> str(d1)
'$1.20'
>>> d2
Dollar(4.63)
>>> str(d2)
'$4.63'
>>> d1+d2
Dollar(5.83)
>>> d1-d2
Dollar(-3.4299999999999997)
>>> print(d1+d2)
$5.83
>>> print(d1-d2)
$-3.43
>>> price = Dollar(0.99)
>>> 'The price is {}'.format(price)
'The price is $0.99'

See, with this double underscore methods you can mess around with the power of python. __add__ let's you override the plus operator, __str__ controls the string conversion and __repr__ the internal interpreter representation.

Of course you should convert your values to Decimal compute with that to avoid aweful rounding errors:

>>> from decimal import Decimal
>>> str(Decimal('0.1'))
'0.1'
>>> class Dollar:
        def __init__(self, value):
	        self.value = Decimal(str(value))
        def __add__(self, other):
	        return Dollar(self.value + other.value)
        def __sub__(self, other):
	        return Dollar(self.value - other.value)
        def __repr__(self):
	        return 'Dollar({})'.format(self.value)
        def __str__(self):
	        return '${:.2f}'.format(self.value)


>>> d1 = Dollar(1.2)
>>> d2 = Dollar(4.63)
>>> d1
Dollar(1.2)
>>> str(d1)
'$1.20'
>>> d2
Dollar(4.63)
>>> str(d2)
'$4.63'
>>> d1+d2
Dollar(5.83)
>>> d1-d2
Dollar(-3.43)
>>> print(d1+d2)
$5.83
>>> print(d1-d2)
$-3.43
>>> price = Dollar(0.99)
>>> 'The price is {}'.format(price)
'The price is $0.99'

Do you see the difference? ;)

Also there is alot more, but for the beginning is that enough.

More on reddit.com

The way most computers compute a power, special cases (NaN, inf, ...) aside, is to do 2^(y*log2(x)) for x^y. This takes 12 x86-64 instructions, although two of them are likely to happen simultaneously. In contrast, x*x is a single x86 instruction. So, for y=2, x*x should be about ten times faster. Python (or any other language) could specialize power to be x*x N times when N <= 10 or so, but the switch statement it takes to specialize the cases isn't free. And the accumulation of floating point errors is not the same between the two. Optimizing pow to a sequence of multiplies is usually done by compilers, which look if you did pow(x,CONSTANT), and decide what to do depending on CONSTANT. That way it is done one time instead of N times at runtime. Python doesn't really have a compiler, so pow is slow for small y, because it would be slower for big y to optimize it for the small ys. Numpy does optimize x**2 to x*x for you, but does not optimize the other powers smaller than ten (actually, I forget if three is also a special optimized case but I know four isn't.) More on reddit.com