¿Python tiene una función “o igual” como || = en Ruby?

Si no, ¿cuál es la mejor manera de hacer esto?

Ahora mismo estoy haciendo (para un proyecto de django):

if not 'thing_for_purpose' in request.session: request.session['thing_for_purpose'] = 5 

pero es bastante incómodo. En Ruby sería:

 request.session['thing_for_purpose'] ||= 5 

que es mucho mejor

La respuesta aceptada es buena para los dictados, pero el título busca un equivalente general al operador || = de Ruby. Una forma común de hacer algo como || = en Python es

 x = x or new_value 

dict tiene setdefault() .

Así que si request.session es un dict :

 request.session.setdefault('thing_for_purpose', 5) 

Establecer un valor predeterminado tiene sentido si lo está haciendo en un middleware o algo así, pero si necesita un valor predeterminado en el contexto de una solicitud:

 request.session.get('thing_for_purpose', 5) # gets a default 

bonus: aquí es cómo hacer realmente un ||= en Python.

 def test_function(self, d=None): 'a simple test function' d = d or {} # ... do things with d and return ... 

Respuesta precisa: No. Python no tiene un solo operador integrado que pueda convertir x = x or y en x op y .

Pero, casi lo hace. El operador bit a bit o igual ( |= ) funcionará como se describe anteriormente si ambos operandos se tratan como booleanos, con una advertencia. (¿Cuál es la advertencia? La respuesta está más abajo, por supuesto.)

Primero, la demostración básica de funcionalidad:

 x = True x Out[141]: True x |= True x Out[142]: True x |= False x Out[143]: True x &= False x Out[144]: False x &= True x Out[145]: False x |= False x Out[146]: False x |= True x Out[147]: True 

La advertencia se debe a que Python no se ha tipificado de forma estricta y, por lo tanto, incluso si los valores se tratan como booleanos en una expresión, no serán cortocircuitados si se les da a un operador de bit a bit. Por ejemplo, supongamos que tenemos una función booleana que borra una lista y devuelve True si hubiera elementos eliminados:

 def my_clear_list(lst): if not lst: return False else: del lst[:] return True 

Ahora podemos ver el comportamiento en cortocircuito como tal:

 x = True lst = [1, 2, 3] x = x or my_clear_list(lst) print(x, lst) Output: True [1, 2, 3] 

Sin embargo, al cambiar de or a modo de bits o ( | ) se elimina el cortocircuito, por lo que se ejecuta la función my_clear_list .

 x = True lst = [1, 2, 3] x = x | my_clear_list(lst) print(x, lst) Output: True [] 

Arriba, x = x | my_clear_list(lst) x = x | my_clear_list(lst) es equivalente a x |= my_clear_list(lst) .

En general, puede usar dict[key] = dict.get(key, 0) + val .