Specific solution

There is no real general solution, but in your case you can use the following expression.

ts_folder = r':.1f'.format(round(value, 1))

General solution

If you actually need some kind of generalization, notice that any non-linear pattern will cause trouble. Although, there is a way to shorten the code.

def classify(key, intervals):
 for lo, hi, value in intervals:
 if lo <= key < hi:
 return value
 else:
 ... # return a default value or None

# A list of tuples (lo, hi, key) which associates any value in the lo to hi interval to key
intervals = [
 (value / 10 - 0.05, value / 10 + 0.05, r':.1f'.format(value / 10))
 for value in range(-9, 10)
]

value = -0.73

ts_folder = classify(value, intervals) # r'-0.7'

Notice that the above is still not totally safe from some float rounding error. You can add precision by manually typing down the intervals list instead of using a comprehension.

The bisect module will do exactly the right lookup for finding the right bin from a list of breakpoints. In fact, the example in the documentation is exactly a case like this:

The bisect() function is generally useful for categorizing numeric data. This example uses bisect() to look up a letter grade for an exam total (say) based on a set of ordered numeric breakpoints: 85 and up is an ‘A’, 75..84 is a ‘B’, etc.

>>> grades = "FEDCBA"
>>> breakpoints = [30, 44, 66, 75, 85]
>>> from bisect import bisect
>>> def grade(total):
... return grades[bisect(breakpoints, total)]
>>> grade(66)
'C'
>>> map(grade, [33, 99, 77, 44, 12, 88])
['E', 'A', 'B', 'D', 'F', 'A']

Instead of a string for the value lookups, you'd want a list of strings for the exact folder names you need for each range of values. For example:

breakpoints = [-0.85, -0.75, -0.65]
folders = [r'-0.9', r'-0.8', r'-0.7']
foldername = folders[bisect(breakpoints, -0.72)]

If you can automate even part of this table generation (using round(), or something similar), of course you should.

All answers revolve around rounding, which seems to be fine in this case, but just for the sake of argument I'd like to also point out a cool python use of dictionaries which is often described as an alternative to other languages switch(es) and that in turn allow for arbitrary values.

ranges = 
 (-0.85, -0.95): r'-0.9',
 (-0.75, -0.85): r'-0.8',
 (-0.65, -0.75): r'-0.7',
 (-0.55, -0.65): r'-0.6'
 ...


def classify (value):
 for (ceiling, floor), rounded_value in ranges.items():
 if floor <= value < ceiling:
 return rounded_value

Output:

>>> classify(-0.78)
-0.8

Why not just use the round() built-in ?

ts_folder = "\" + str(round(value + 1e-16, 1))

(The +1e-16 etc is because floats like .15 are by default rounded to .1, not .2)

More on round()

One of the first rules with a block of code like this, is to always make the comparisons be in the same direction. So instead of

 elif value < -0.75 and value >= -0.85:

write

 elif -0.85 <= value and value < -0.75:

At this point you can observe that python allows chaining of comparisons, so you can write:

 elif -0.85 <= value < -0.75:

Which is an improvement itself. Alternatively, you can observe this is an ordered list of comparisons, so if you add in an initial comparisons, you can just write

 if value < -0.95:
 ts_folder = ''
 elif value < -0.85:
 ts_folder = r'-0.9'
 elif value < -0.75:
 ts_folder = r'-0.8'
 elif value < -0.65:
 ts_folder = r'-0.7' 
 elif value < -0.55:
 ts_folder = r'-0.6' 
 elif value < -0.45:
 ts_folder = r'-0.5' 
 elif value < -0.35:
 ts_folder = r'-0.4'
 elif value < -0.25:
 ts_folder = r'-0.3'
 elif value < -0.15:
 ts_folder = r'-0.2'
 elif value < -0.05:
 ts_folder = r'-0.1'
 elif value < 0.05:
 ts_folder = r'.0'
 elif value < 0.15:
 ts_folder = r'.1'
 elif value < 0.25:
 ts_folder = r'.2'
 elif value < 0.35:
 ts_folder = r'.3'
 elif value < 0.45:
 ts_folder = r'.4'
 elif value < 0.55:
 ts_folder = r'.5'
 elif value < 0.65:
 ts_folder = r'.6'
 elif value < 0.75:
 ts_folder = r'.7' 
 elif value < 0.85:
 ts_folder = r'.8'
 elif value < 0.95:
 ts_folder = r'.9'
 else:
 ts_folder = ''

That's still quite long, but a) it's a lot more readable; b) it has explicit code to handle value < -0.95 or 0.95 <= value

Actually in Python 3 .85 will be round to .8. As per the question .85 should be round to .9.

Can you try the following:

round2 = lambda x, y=None: round(x+1e-15, y)
ts_folder = r''.format(str(round2(value, 1)))

Output:

>>> round2(.85, 1)
0.9
>>> round2(-.85, 1)
-0.8

Take a look at the round() function in python. Maybe you can work it out without the if.

With this function you can specify the number of digits you need to keep.
For example :

x = round(5.76543, 2)
print(x)

That code will print 5.77

How about turning it into a loop?

def classify(value):
 i = -5
 while i < 95:
 if value < (i + 10) / 100.0 and value >= i / 100.0:
 return '\' + repr((i + 5) / 100.0)
 i += 10

it's not efficient by any means, but it's equivalent to what you have, just shorter.

from decimal import Decimal

def classify(value):
 number = Decimal(value)
 result = "%.2f" % (number)
 return Decimal(round(float(result), 2))

You don't need the and value >= -.85 in elif value < -0.75 and value >= -0.85:; if the value isn't greater than or equal to -.85, then you won't reach the elif. You can also just turn all the elifs into if by having each one return immediately.

In this case, since you have the boundaries at regular intervals, you can just round (in the general case of regular intervals, you may have to divide and then round, for instance if the intervals are at every three units, then you would divide the number by three and round). In the general case, it's faster to store the boundaries in a tree structure, and then do a binary search for where the item goes.

Doing a binary search explicitly would be something like this:

def classify(value): 
 if value < -.05:
 if value < -.45:
 if value < -.65:
 if value < -.85:
 if value < -.95:
 return None
 return r'-0.9'
 if value < -.75:
 return r'-0.8'
 return r'-0.7'
 ...

Although this code is harder to read than yours, it runs in time logarithmic rather than linear with respect to the number of boundaries.

If the number of items is significantly larger than the number of boundaries, it would probably be faster to actually create a tree of the items, and insert the boundaries.

You could also create a list, sort it, and then look at the index. For instance, compare (sorted([(_-9.5)/10 for _ in range(20)]+[x]).index(x)-9)/10 to your function.

Try something like this, if you don't like loops:

def classify(value): 
 endpts = [-0.95, -0.85, -0.75, -0.65, -0.55, -0.45, -0.35, -0.25, -0.15, -0.05, 0.05, 0.15, 0.25, 0.35, 0.45, 0.55, 0.65, 0.75, 0.85, 0.95] 
 ts_folder = [ r'-0.9', r'-0.8', r'-0.7', r'-0.6', r'-0.5', r'-0.4', r'-0.3', r'-0.2', r'-0.1', r'.0', r'.1', r'.2', r'.3', r'.4', r'.5', r'.6', r'.7', r'.8', r'.9'] 
 idx = [value >= end for end in endpts].index(False) 
 if not idx:
 raise ValueError('Value outside of range')
 return ts_folder[idx-1] 

Of course, the loop is just "hidden" in the list comprehension.
Obviously, in this example, it would be better to generate endpts and ts_fol programmatically rather than writing them all out, but you indicated that in the real situation the endpoints and values aren't so straightforward.

This raises a ValueError if value ≥ 0.95 (because False is not found in the list comprehension) or if value < -0.95 (because then idx is 0); the original version raises a UnboundLocalError in these cases.

You could also save three lines and skip a few comparisons by doing this:

def classify(value):
 endpts = [-0.95, -0.85, -0.75, -0.65, -0.55, -0.45, -0.35, -0.25, -0.15, -0.05, 0.05, 0.15, 0.25, 0.35, 0.45, 0.55, 0.65, 0.75, 0.85, 0.95]
 ts_fol = [ None, r'-0.9', r'-0.8', r'-0.7', r'-0.6', r'-0.5', r'-0.4', r'-0.3', r'-0.2', r'-0.1', r'.0', r'.1', r'.2', r'.3', r'.4', r'.5', r'.6', r'.7', r'.8', r'.9']
 return next((ts for ts, end in zip(ts_fol, endpts) if value < end), None)

This version returns None rather than raising exceptions for any value outside the bounds.