Création d'une bibliothèque Python pour écrire des inclusions complexes et les réduire de manière facile à lire

J'ai écrit un article comme Astuces pour écrire une notation d'inclusion compliquée de manière facile à lire, mais j'ai créé une bibliothèque appelée xcomp basée dessus. .. Disponible sur Github.

Voici les objectifs de base.

• Normalement pour l'ordre des mots de la phrase
• Avec indentation
• Sans changement d'état
• Initialiser la collection

Installation

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

comp(collector)

for xcomp import comp

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

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

#Vous pouvez également prendre la somme. dict et set sont également possibles
@comp(sum)
def a():
    for i in range(5):
        yield i

# a == 10

#Facile à lire, même les inclusions compliquées
@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) Si vous souhaitez créer plusieurs collections en une seule boucle.

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)

Un décorateur pour écrire des functools.reduce un peu plus facile à lire. Raquette [pour / fold](https://docs.racket-lang.org/reference/for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Ffold% 29% 29) est l'histoire originale.

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

#Nested for est également 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)]

#Lors de l'ajout d'un effort à la fin
@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,soutient également continuer
@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

(Est-ce vraiment facile à lire ...?)

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

Reduce_comp quand il y a plusieurs variables d'accumulation. Ceci est proche du "for / fold" de Racket.

@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)

Fonction d'ordre supérieur pour tourner le premier argument vers la fin. delay_arg (f, * args, ** kwargs) (a) devient f (a, * args, ** kwargs).

Vous pouvez utiliser map, filter, reduction comme décorateurs.

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

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