Podmínka jako parametr – Python – Fórum – Programujte.com

Ahoj,

nevíte někdo, jak udělat funkci které by šlo předávat v parametrech podmínku podobně jako v numpy?

np.where(a==2, a, 0)

Do toho where nejde podmínka, ale výsledek toho porovnání. 

a=np.array([1,2,3])

a==2
# a: [1,2,3]
# 2: [2,2,2]
# => [False, True, False]

np.where(a==2, a, 0)
# cond: [False, True, False]
#    x: [1, 2, 3]
#    y: [0, 0, 0]
# => [0, 2, 0]

Pokud potřebuješ předávat něco jako podmínku, tak můžeš předávat funkci a tu v té cílové funkci volat.

Děkuji, to dává smysl. Možnost s funkcí znám, ale někdo říkal, že by to šlo i nějak udělat jakoby lambdu bez toho slova lambda a psát jen jakoby podmínku. Tak jsem myslel, že to je právě v numpy.

Můžeš přetěžovat operátory. Pokud máš v tom výrazu svůj objekt, tak máš kontrolu nad jeho výsledkem. Takže můžeš vyrábět i funkci, ale je lepší neměnit význam operátorů, aby tě to pak někde nepřekvapilo.

class Filter:
    def __gt__(self, other):  # Greater Than
        return lambda x: x > other

    def __lt__(self, other):  # Less Than
        return lambda x: x < other


x = Filter()
data = [1, 2, 3, 4, 5]

print(*filter(x > 2, data))  # 3 4 5
print(*filter(x < 4, data))  # 1 2 3

Znova děkuji. Zkouším to ještě upravit aby fungovaly i vícenásobné podmínky (a > 2 and a < 5) a jestli to správně chápu tak z první podmínky musím zase vrátit svůj objekt abych na něm udělal tu další podmínku. Dá se nějak poznat jestli následuje další podmínka abych věděl jestli vrátit funkci nebo objekt?

Můžeš vracet pořád objekt a definovat mu __call__, takže bude použitelný i jako funkce. To ve skutečnosti jsou i "normální" funce - volatelné objekty. Všechny tyhle speciální metody jsou popsané tady.

Akorát and nejde přetížit, můžeš to zřetězit bez něj, nebo použít podobný & (ten ale má ale jinou prioritu, tak to musíš správně ozávorkovat) 

class Filter:
    def __init__(self, func=lambda x: True):
        self.func = func

    def __gt__(self, other):
        return Filter(lambda x: self(x) and x > other)

    def __lt__(self, other):
        return Filter(lambda x: self(x) and x < other)

    def __and__(self, other):  # &
        return Filter(lambda x: self(x) and other(x))

    def __call__(self, x):
        return self.func(x)


x = Filter()
data = [1, 2, 3, 4, 5]

print(*filter(x > 2, data))              # 3 4 5
print(*filter((x > 2) < 5, data))        # 3 4
print(*filter((x > 2) & (x < 5), data))  # 3 4

Na hraní pěkné, ale nikde to proboha nepoužívej :-)

Super díky moc. Já to nebudu používat a právě jen si tak hraju.