How to handle functions return value in Python

If an author believes a function should only return only one type (None really isn't a return value, it's the absence of one in most cases), the correct answer in this case would be to throw an exception. The correct logic here, IMO, using the EAFP principle is:

 def multiply_by_ten(arg):
    return float(arg) * 10


try:
    result = multiply_by_ten('abc')
except ValueError:
    pass

I also really don't recommend repeating what the standard library already does for you, since your own implementation is typically worse than what is already done for you. For example:

>>> "0.01e-6".isdigit()
False
>>> float("0.01e-6")
1e-8

If the function already checks the validity of the arguments passed too it, and throws an exception on failure, you don't need to double-check it.

Finally, I think the idea that a function should return a single type is dangerous: exception handling is great, so is returning invalid flags, but Python is a dynamic language for a reason: it allows polymorphism by design. Use it within reason.

Finally, a little perspective. In C++, a statically typed language, there exist probably a thousand different implementations of any, optional, union, and variant, all which aim to hold multiple types in the same container. Even in statically-typed languages, polymorphism is useful. If used sparing, polymorphism is a useful feature of a language.

The common practice to handle an error in Python is not by returning a value different from the expected value type, but by raising an exception.

As pointed by @AGN Gazer, you will go even faster by catching the exception of an erroneous cast, avoiding you a function to make a simple multiplication:

try:
   result = float('abc') * 10
except:
   print('Error: not a valid number')

If we stay on your old code structure, instead of:

def multiply_by_ten(arg):
   if not str(arg).isdigit():
       print 'arg is not a digit'
       return
   return float(arg) * 10

You should do:

def multiply_by_ten(arg):
   if not str(arg).isdigit():
       raise Exception('NotNumber', 'The argument is not a number')
   # Do some other stuff? Otherwise not really helpful
   return float(arg) * 10

And in your call:

try:
   result = multiply_by_ten('abc')
catch Exception as e:
   if e.args[0] == 'NotNumber':
      print('Error: '+e.args[1])
   else:
      raise

If you are always expecting a number raise an exception, this means there was a problem.

If the value can be missing and it doesn't have any conflict with the program logic return None.

And the most important thing is code consistency - what do you do in other places of your code?

The arbitrary decision to say that any given function should only return a single type of value is just that: arbitrary.

In this case, because you are returning a numeric value, without using None OR a string indicating that a problem has occurred, you would be limited to trying to return some number to indicate that a problem had occurred: some functions return numbers like -1 as signals that a problem arose. But that would not work in this case, if the input were -0.1.

If, as you say, you really do want to return only a single type of value (always ints OR always floats), then I don't see many options besides checking beforehand.

Options might include using a try/except statement as the other authors suggest.

This is silly. A function always returns exactly one type. If the function can return either an int or None, then it's a sum type, specifically Optional[int].