Quando si utilizza l'interprete, l'espressione 'a' in ('abc') restituisce True, mentre 'a' in ['abc'] restituisce False. Qualcuno può spiegare questo comportamento?Perché 'a' in ('abc') True mentre 'a' in ['abc'] è False?
('abc') è lo stesso di 'abc'. 'abc' contiene la sottostringa 'a', quindi 'a' in 'abc' == True.
Se si desidera la tupla, è necessario scrivere ('abc',).
['abc'] è un elenco (contenente un singolo elemento, la stringa 'abc'). 'a' non è un membro di questo elenco, quindi 'a' in ['abc'] == False
('abc') non è una tupla. Penso che tu abbia confuso quello con la tupla ('abc',).
realtà, ('abc') è stessa 'abc', un array of characters dove a come personaggio è in essa, quindi, la prima ricerca restituisce True:
>>> 'a' in 'abc'
True
D'altra parte, ['abc'] è un elenco di stringa o un lista della lista di caratteri (si può pensare come una matrice 2-d di caratteri [['a', 'b', 'c']]) dove a, come singolo carattere, non è il membro della lista esterna. In realtà, è il primo carattere dell'elenco interno:
>>> 'a' in ['abc']
False
>>> 'a' in ['abc'][0]
True
>>> 'a' == ['abc'][0][0]
True
Puoi dirmi e/o aggiungere un riferimento sul significato di questo '' a '== [' abc '] [0] [0] ' – Ahmed
' a '== [' abc '] [0] [0 ] "a" è in (lista first elem> first char) – dsgdfg
In altre parole, una volta applicato il primo '[0]', si rimane con ''a' == 'abc' [0]' (dà il primo elemento della lista), quindi, dopo aver applicato il secondo '[0]', si rimane con ''a' == 'a'', che valuta come' Vero'. – Carcigenicate
Come altri hanno menzionato, ('abc') non è una tupla. 'a' non è un elemento di ['abc']. L'unico elemento in tale elenco è 'abc'
x='abc' in ['abc']
print (x)
True #This will evaluate to true
Questo sarà anche valutata come vera:
y = 'a' in ['a','b','c']
print (y)
True
Per ('abc') si ottiene 'a' in ('abc') return true.
Ma per ['abc'] in quanto è un elenco di array si ottiene 'a' in ['abc'] return false.
Esempio:
ingresso:('abc') == 'abc'
uscita:True
Quindi, se noi chiamiamo 'a' in ('abc') è uguale a 'a' in 'abc' perché ('abc') non è una tupla ma 'abc' è una matrice di caratteri in cui il carattere 'a' è nell'indice 0 della stringa 'abc'.
D'altra parte ['abc'] è una lista di array dove 'abc' è una singola stringa che è all'indice 0 di array ['abc'].
Tupple Esempio:x = ('abc', 'def', 'mnop')
Array Esempio:x = ['abc', 'def', 'mnop']
o
x = ('abc'), y = 'abc'
Qui sempre x == y.
Ma in caso di 'a' in ['abc'] =>
x = ['abc'], y = 'abc'
Qui x != y ma x[0] == y
('abc') è equivalente a 'abc'.
'a' in ('abc') equivale a 'a' in 'abc'.
'a' in ('abc',) restituisce False come 'a' in ['abc'].
'a' in ['a', 'b', 'c'] restituisce True come 'a' in 'abc'.
'('abc')' non è una tupla, è solo la stringa ''abc''. Per verificare effettivamente l'appartenenza ad una tupla contenente la stringa ''abc'', usare' a in (' abc ',) '. – dano
dovuto al doppio uso della parentesi per la precedenza di espressione e per le tuple, che portano a quella strana sintassi per le singole tuple di elementi – njzk2
Le parentesi in '('abc')' sono solo per la decorazione e anche una potenziale fonte di confusione. Mi ci è voluto un po 'per superare questo; Anch'io pensavo che le parentesi indicavano qualcosa di speciale (c.f. parentesi quadre o parentesi graffe, che significano qualcosa di speciale). In questo utilizzo, quelle parentesi hanno zero significati. Non c'è differenza tra 'xyz = (x, y, z)' e 'xyz = x, y, z'. È la presenza di una virgola che ha un significato speciale (tranne nel caso di una tupla vuota, dove '()' ha un significato speciale). –