Si no es así, ¿cuál es la mejor forma de hacerlo?
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.
nil
(falso en contexto booleano), este modismo se usa a menudo exactamente para el propósito que Sean lo haya usado. Sin embargo, el idioma solo funciona si, por supuesto,nil
yfalse
no son valores legítimos en el hash (lo cual es muy a menudo cierto, por lo que el idioma está bien)//=
que se encuentra en perl . Creo que||=
también se origina en Perl.Respuestas:
La respuesta aceptada es buena para 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
fuente
x
se ha definido previamente (por ejemplo, establecido enNone
en un método de inicialización de clase).dict
tienesetdefault()
.Entonces, si
request.session
es undict
:request.session.setdefault('thing_for_purpose', 5)
fuente
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
bonificación: aquí se explica cómo hacer realmente una
||=
en Python.def test_function(self, d=None): 'a simple test function' d = d or {} # ... do things with d and return ...
fuente
Respuesta precisa: No. Python no tiene un solo operador incorporado
op
que pueda traducirsex = x or y
enx op y
.Pero casi lo hace. El bit a bit o es igual operador (
|=
) voluntad función como se describe anteriormente si ambos operandos están siendo tratados como booleanos, con una advertencia. (¿Cuál es la advertencia? La respuesta está a continuación, 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 es que Python no se escribe estrictamente y, por lo tanto, incluso si los valores se tratan como booleanos en una expresión, no se cortocircuitarán si se les da a un operador bit a bit. Por ejemplo, supongamos que tenemos una función booleana que borra una lista y devuelve
True
si hay elementos eliminados:def my_clear_list(lst): if not lst: return False else: del lst[:] return True
Ahora podemos ver el comportamiento en cortocircuito así:
x = True lst = [1, 2, 3] x = x or my_clear_list(lst) print(x, lst) Output: True [1, 2, 3]
Sin embargo, cambiar
or
a bit a bit o (|
) elimina el cortocircuito, por lo que la función semy_clear_list
ejecuta.x = True lst = [1, 2, 3] x = x | my_clear_list(lst) print(x, lst) Output: True []
Arriba,
x = x | my_clear_list(lst)
es equivalente ax |= my_clear_list(lst)
.fuente
En general, puede utilizar
dict[key] = dict.get(key, 0) + val
.fuente