[Python] 0 in (False,) // 0 == False

[Pietro Battiston]

Il giorno sab, 06/02/2010 alle 23.03 +0100, Enrico Franchi ha scritto:
> On Feb 5, 2010, at 8:24 PM, Alessandro Dentella wrote:
> 
> > in attesa che Enrico mantenga la
> > promessa e mostri gli "assurdi completi" che quanto scritto sopra
> > comporterebbe. 
> 
> Essenzialmente ha spiegato tutto già Daniele. Gli assurdi saltano fuori
> dalla posizione:
> 
>  In an ideal world, bool might be better implemented as a
>       separate integer type that knows how to perform mixed-mode
>       arithmetic.
> 
> Ovvero noi *vogliamo* mixed mode arithmetic. Tolto questo assunto,
> è ovviamente completamente possibile gestire in modo consistente
> le operazioni fra interi e booleani lanciando eccezioni.
> 
> Il punto è che IMHO l'aritmetica che coinvolge i booleani è estremamente
> comoda. Evidentemente anche secondo Guido. 
> 
> Quindi partiamo dal volere che un booleano possa stare in ogni posto 
> dove possa stare un intero.
> 

Il punto che forse non è chiaro è cosa sia l'aritmetica.

Sia dal punto di vista matematico che da quello del Python, "==" è
qualcosa che non ha _niente_ a che fare con l'aritmetica: dal punto di
vista logico-matematico perché l'eguaglianza non è (necessariamente) un
operatore, dal punto di vista di come ragiona il Python perché "==" può
confrontare due oggetti qualsiasi, non solo numerici. Diventa
l'uguaglianza tra numeri... esattamente quando gli argomenti sono due
numeri.

> Consideriamo anche ragionevole che:
> 
> 1) a + (-a) == a - a == 0
> 
> 2) m - n < 0 <==> m < n


Dove a, m e n sono interi, certo.

> 
> 
> Ma soprattutto chiediamoci cosa *dovrebbe* fare
> 
> False + True o una cosa come
> 
> True * 5
> 
> è completamente chiaro che il tutto è relativamente arbitrario (in particolare
> True == 5 invece che True == 1 non darebbe problemi).
> 
> Ma prendere False != da 0 ci porrebbe nell'imbarazzante condizione di avere
> 
> if 0: print "foo"
> 
> che stampa "foo". 

Stai scherzando?! Questo punto è stato chiarito 5 mail fa.
_Evidentemente_ bool(0) == False.


> 
> Comunque davvero, la cosa più naturale è vedere True e False come numeri a 1-bit.

Non dubito che per te possa essere (ormai?) naturale...

> Non ci formalizziamo perchè 0 == 0L, ma ci da fastidio False. 

... ma renditi conto che questo è un argomento che non c'entra niente.

Tutti i tipi numerici hanno somma, sottrazione, moltiplicazione,
divisione (questa, con qualche distinguo), che definiscono su di essi
delle immersioni che sono più che canoniche, sono _ovvie_: i naturali
(chiusi solo per la somma) sono degli interi (chiusi per somma,
sottrazione, prodotto), che sono dei razionali (OK, questi l'informatica
per quanto ne so ce li risparmia), che sono dei reali (chiusi per tutte
le operazioni - tralasciando la rappresentazione approssimata), che
volendo sono dei complessi.

In tutto ciò i booleani, che sono nati come logica a due valori in cui
le due operazioni "standard" erano or (l'equivalente intero è "max", non
una delle operazioni aritmetiche) e and ("min"), sono un caso a parte.
Ma non c'è solo problema storico: c'è che seppure l'addizione (così come
la sottrazione) assomiglia ad un'operazione logica, lo xor, purtroppo
l'insieme dei booleani _non è chiuso_ rispetto ad essa (dato che anche
assumendo che i booleani siano numeri, True + True non sarebbe un
booleano): ovvero non si comporta affatto come lo xor. Quindi _comunque_
quando parliamo di addizione di booleani è piuttosto ipocrita spacciarla
per un'operazione "nativa": è, come tutti hanno ammesso, una comodissima
eredità del C.

D'altronde, vedila in un altro modo: se per te è perfettamente naturale
che i booleani siano semplicemente (un piccolo sottoinsieme degli)
interi, e ti sembra quindi naturale che siano _identici_ in tutto e per
tutto rispettivamente a 0 e 1, non ti sembrerebbe naturale anche che

In [1]: isinstance(1,bool)
Out[1]: True

?!

La scomoda verità è che se volessimo una cosa "pulita" con False != 0,
il modo giusto sarebbe che, come in C, False e True fossero
semplicemente _definiti_ individualmente come 0 e 1. Solo che il tipo
"bool" ci fa comodo... mentre la riga di codice che ho scritto sopra è
assolutamente inutile.

Ciò detto, ho già scritto che in fondo me ne frega assai: è evidente
che, posto che Guido si è già espresso, tutto il thread è puramente
teorico.

> 
> Se vogliamo fare aritmetica mista (che è l'assunto), ci troviamo a dovere dare convenzionalmente
> un valore a True e False. E ovviamente tutte le scelte possibili sarebbero peggiori e meno
> intuitive di questa.
> 

Se vuoi ribattere, fallo con precisione su uno dei punti esposti finora
in una delle tante mail, che sennò non si finisce più.

ciao

Pietro