Erstellt eine Python-Bibliothek, um komplexe Einschlüsse zu schreiben und auf einfach zu lesende Weise zu reduzieren

Ich habe einen Artikel wie Tipps zum Schreiben einer komplizierten Einschlussnotation auf einfach zu lesende Weise geschrieben, aber darauf basierend eine Bibliothek namens xcomp erstellt. .. Verfügbar auf Github.

Das Folgende sind die grundlegenden Ziele.

• Normal für Satzwortreihenfolge
• Mit Einrückung
• Ohne Zustandsänderung
• Initialisieren Sie die Sammlung

Installation

pip install git+git://github.com/ukyo-su/xcomp@master

comp(collector)

for xcomp import comp

# a = [i for i in range(5)]Anstatt
@comp(list)
def a():
    for i in range(5):
        yield i

# a == [0, 1, 2, 3, 4]

#Sie können auch die Summe nehmen. diktieren und setzen sind ebenfalls möglich
@comp(sum)
def a():
    for i in range(5):
        yield i

# a == 10

#Leicht zu lesen, auch komplizierte Einschlüsse
@comp(list)
def fizz_buzz():
    for i in range(30):
        if i % 15 == 0:
            yield "Fizz Buzz"
        elif i % 3 == 0:
            yield "Fizz"
        elif i % 5 == 0:
            yield "Buzz"
        else:
            yield i

multi_comp(*collectors) Wenn Sie mehrere Sammlungen in einer Schleife erstellen möchten.

from xcomp import multi_comp

data = [(0, 1), (2, 3)]

@multi_comp(list, list)
def a():
    for i, j in data:
        yield i, j

a_i, a_j = a

# a_i == [0, 2]
# a_j == [1, 3]

reduce_comp(init, for_=None, for_nest=(), result=lambda x: x)

Ein Dekorateur zum Schreiben von functools.reduce ein wenig leichter zu lesen. Racket's [for / fold](https://docs.racket-lang.org/reference/for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Ffold% 29% 29) ist die ursprüngliche Geschichte.

from xcomp import reduce_comp

# reduce(lambda sum_, i: sum_ + i, range(5), 0)
@reduce_comp(0, for_=range(5))
def a(sum_, i):
    return sum_ + i

# a == 10

#Verschachtelt für ist auch OK
@reduce_comp([], for_nest=(range(3), range(2)))
def a(acc, i, j):
    return [*acc, (i, j)]

# a == [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

#Wenn Sie am Ende einen Versuch hinzufügen
@reduce_comp([], for_=range(5),
             result=lambda x: list(reversed(x)))
def a(acc, i):
    return [*acc, i]

# a == [4, 3, 2, 1, 0]

# break,unterstützt auch weiterhin
@reduce_comp(0, for_=range(100))
def a(acc, i):
    if i > 5:
        raise BreakReduce
    return acc + 1

# a == 6

@reduce_comp(0, for_=range(10))
def a(acc, i):
    if i < 5:
        raise ContinueReduce
    return acc + i

# a == 35

(Ist es wirklich leicht zu lesen ...?)

multi_reduce_comp(*inits, for_=None, for_nest=(), result=lambda *args: args)

Reduce_comp wenn es mehrere akkumulierende Variablen gibt. Dies ist in der Nähe von Rackets "for / fold".

@multi_reduce_comp(0, [],
                   for_=range(5))
def a(sum_, rev_list, i):
    return sum_ + i, [i, *rev_list]

a_sum, a_rev_list = a

# a_sum == 10
# a_rev_list == [4, 3, 2, 1, 0]

@multi_reduce_comp([], set(),
                   for_=[0, 1, 1, 2, 3, 4, 4, 4],
                   result=lambda acc, seen: list(reversed(acc)))
def a(acc, seen, i):
    if i in seen:
        return acc, seen
    else:
        return [i, *acc], {*seen, i}

# a == [0, 1, 2, 3, 4]

delay_arg(func, *args, **kwargs)

Funktion höherer Ordnung, um das erste Argument zu beenden. delay_arg (f, * args, ** kwargs) (a) wird zu f (a, * args, ** kwargs).

Sie können "Karte", "Filter", "Reduzieren" als Dekorateure verwenden.

@list
@delay_arg(map, range(5))
def a(i):
    return i * 2

# a == [0, 2, 4, 6, 8]