Python: ¿la forma más idiomática de convertir None en una cadena vacía?

¿Cuál es la forma más idiomática de hacer lo siguiente?

def xstr(s):
    if s is None:
        return ''
    else:
        return s

s = xstr(a) + xstr(b)

actualización: estoy incorporando la sugerencia de Tryptich de usar str (s), lo que hace que esta rutina funcione para otros tipos además de las cadenas. Estoy terriblemente impresionado por la sugerencia lambda de Vinay Sajip, pero quiero mantener mi código relativamente simple.

def xstr(s):
    if s is None:
        return ''
    else:
        return str(s)

Si realmente desea que su función se comporte como la str()integrada, pero devuelva una cadena vacía cuando el argumento es Ninguno, haga esto:

def xstr(s):
    if s is None:
        return ''
    return str(s)

def xstr(s):
    return '' if s is None else str(s)

Probablemente lo más corto sería str(s or '')

Porque Ninguno es falso, y "x o y" devuelve y si x es falso. Ver operadores booleanos para una explicación detallada. Es breve, pero no muy explícito.

Si sabe que el valor siempre será una cadena o Ninguno:

xstr = lambda s: s or ""

print xstr("a") + xstr("b") # -> 'ab'
print xstr("a") + xstr(None) # -> 'a'
print xstr(None) + xstr("b") # -> 'b'
print xstr(None) + xstr(None) # -> ''

return s or '' ¡funcionará bien para su problema declarado!

def xstr(s):
   return s or ""

Forma funcional (una línea)

xstr = lambda s: '' if s is None else s

Una buena frase para hacer esta construcción en algunas de las otras respuestas:

s = (lambda v: v or '')(a) + (lambda v: v or '')(b)

o incluso solo:

s = (a or '') + (b or '')

def xstr(s):
    return {None:''}.get(s, s)

Yo uso la función max:

max(None, '')  #Returns blank
max("Hello",'') #Returns Hello

Funciona como un encanto;) Simplemente ponga su cadena en el primer parámetro de la función.

Variación sobre lo anterior si necesita ser compatible con Python 2.4

xstr = lambda s: s is not None and s or ''

Si se trata de formatear cadenas, puede hacer lo siguiente:

from string import Formatter

class NoneAsEmptyFormatter(Formatter):
    def get_value(self, key, args, kwargs):
        v = super().get_value(key, args, kwargs)
        return '' if v is None else v

fmt = NoneAsEmptyFormatter()
s = fmt.format('{}{}', a, b)

def xstr(s):
    return s if s else ''

s = "%s%s" % (xstr(a), xstr(b))

Siempre podemos evitar la conversión de tipos en los escenarios que se explican a continuación.

customer = "John"
name = str(customer)
if name is None
   print "Name is blank"
else: 
   print "Customer name : " + name

En el ejemplo anterior, en caso de que el valor del cliente variable sea Ninguno, se convierte más cuando se le asigna 'nombre'. La comparación en la cláusula 'if' siempre fallará.

customer = "John" # even though its None still it will work properly.
name = customer
if name is None
   print "Name is blank"
else: 
   print "Customer name : " + str(name)

El ejemplo anterior funcionará correctamente. Tales escenarios son muy comunes cuando los valores se obtienen de URL, JSON o XML o incluso los valores necesitan una conversión de tipo adicional para cualquier manipulación.

Utilice la evaluación de cortocircuito:

s = a or '' + b or ''

Dado que + no es una muy buena operación en cadenas, mejor use cadenas de formato:

s = "%s%s" % (a or '', b or '')

Use la cadena F si está usando Python v3.7

xstr = F"{s}"