appartenenza lista in Python senza "in"

voti
2

Come definire una funzione IS_MEMBER () che accetta un valore (vale a dire un numero, una stringa, ecc) x e un elenco di valori a, e restituisce True se x è un membro di una, False altrimenti. (Si noti che questo è esattamente ciò che l'operatore in fa, ma per il bene dell'esercizio dovrei fingere di Python non ha avuto questo operatore.

Questo è ciò che mi è venuta in mente, ma non funziona!

def is_member(x, a):
   return x == a[::]
È pubblicato 24/10/2010 alle 12:20
fonte dall'utente
In altre lingue...                            


6 risposte

voti
1

Si potrebbe semplicemente iterare su ogni elemento della lista, allora:

def is_member(col, a):
    for i in xrange(len(col)):
        if a == col[i]: return True
    return False


>> a = [1,2,3,4]
>> is_member(a, 2)
True
>> is_member(a, 5)
False
Risposto il 24/10/2010 a 12:28
fonte dall'utente

voti
4

Mi vengono in mente due ( edit: tre) modi per fare questo:

Primo:

def is_member(array, value):
    try:
        array.index(value)
    except ValueError:
        return False
    else:
        return True

Secondo:

def is_member(array, value):
    for item in array:
        if item == value:
            return True
    return False

EDIT: Inoltre, il terzo:

def is_member(array, value):
    return array.count(value) > 0
Risposto il 24/10/2010 a 12:29
fonte dall'utente

voti
2

Utilizzando un generatore di espressione (notare che questo inoperatore non ha nulla a che fare con l'altro)

def is_member(x, a):
   return any(x == y for y in a)

>>> is_member(10, xrange(1000000000000000))
True
Risposto il 24/10/2010 a 13:24
fonte dall'utente

voti
3

soluzione ricorsiva:

def is_member(value, array):
    if len(array) == 0:
        return False
    return value == array[0] or is_member(value, array[1:])
Risposto il 24/10/2010 a 13:40
fonte dall'utente

voti
1

Senza usare l'operatore "in":

from itertools import imap
def is_member( item, array ):
    return any( imap(lambda x: x == item, array ) )

che ciclo tra gli elementi della lista, uno alla volta, e corto circuito quando colpisce un valore che è True.

Risposto il 24/10/2010 a 13:59
fonte dall'utente

voti
0

Beh, ci sono un sacco di modi per fare questo, naturalmente - ma tu sei un po 'ostacolato dal divieto di "in" in qualsiasi parte del codice. Qui ci sono alcune cose da provare.

Variazioni su un tema ...

def is_member(item, seq):
    return sum(map(lambda x: x == item, seq)) > 0

def is_member(item, seq):
    return len(filter(lambda x: x != item, seq)) != len(seq)

Potreste aver sentito che la richiesta di perdono è meglio che chiedere il permesso ...

def is_member(item, seq):
    try:
        seq.index(item)
        return True
    except:
        return False

O qualcosa di un po 'più funzionale al gusto di ...

import itertools, operator, functools
def is_member(item, seq):
    not_eq = functools.partial(operator.ne, item)
    return bool(list(itertools.dropwhile(not_eq, seq)))

Ma, dal momento che le vostre esigenze precludono l'uso del costrutto iterativo che sarebbe più ragionevole, credo che gli esperti consiglierebbero scrivere il proprio quadro looping. Qualcosa di simile a ...

def loop(action, until):
    while True:
        action()
        if until():
            break

def is_member(item, seq):
    seq   = seq
    sigil = [False]

    def check():
        if seq[0] == item:
            sigil[0] = True
    def til():
        seq.remove(seq[0])
        return not len(seq)

    loop(check, til)

    return sigil[0]

Fateci sapere come va.

Risposto il 24/10/2010 a 19:47
fonte dall'utente

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more