[PYTHON] Combinaison de récursif et de générateur

• Cet article est un test de Qiita.

Dans certains cas, récursif peut être exprimé avec une structure simple en combinant récursif et générateur.

Récurrence d'expression régulière

Difficile de gérer les parenthèses récursives dans les expressions régulières. En PHP et Ruby, les expressions régulières ont leur propre syntaxe, mais pas Python. En utilisant une fonction récursive, il est assez facile de gérer les parenthèses.

import re
prog = re.compile(r"\((.+)\)")

def rec_search(s):
    "Obtenir les parenthèses récursivement et revenir dans la liste"
    match = prog.search(s)
    r = []
    if match:
        r.append(match)
        for i in rec_search(match.group(1)):
            r.append(i)
    return r

Je dresse une liste et la renvoie à l'appelant. Ça a l'air un peu sale.

Combiner avec générateur

import re
prog = re.compile(r"\((.+)\)")

def recsearch(s):
    "Obtenir les parenthèses de manière récursive et itérer"
    match = prog.search(s)
    if match:
        yield match
        for i in rec_search(match.group(1)):
            yield i

C'est assez simple. Si vous «cédez» la valeur, vous pouvez supprimer la valeur, ce qui est facile. Notez que rec_search est un générateur, donc yield le renvoie à l'appelant. Sinon, un appel de fonction qui ne fait rien se produira et se terminera.

Résultat d'exécution

>>> for i in rec_search("(1 + (1 + 2))"):
	print(i)

<_sre.SRE_Match object; span=(0, 13), match='(1 + (1 + 2))'>
<_sre.SRE_Match object; span=(4, 11), match='(1 + 2)'>

Rendez-le encore plus simple avec le rendement de

Introduit dans python3.3. Exécutez la fonction de générateur spécifiée par yield from et attendez à l'appelant que tous les résultats soient renvoyés. Une version d'essai yield from de la fonction ci-dessus.

import re
prog = re.compile(r"\((.+)\)")

def rec_search(s):
    "Obtenir les parenthèses de manière récursive et itérer"
    match = prog.search(s)
    if match:
        yield match
        yield from rec_search(match.group(1))

C'est encore plus court et plus simple.

Obtenir le nom du fichier de manière récursive

import os

def iter(dirctory):
    "Itérer tous les fichiers sous le répertoire"
    d = os.listdir(dirctory)
    if d:
        for f in (os.path.join(dirctory, f) for f in d):
            if os.path.isfile(f):
                yield f
            elif os.path.isdir(f):
                yield from iter(f):

ʻOs.listdir` Un exemple d'acquisition récursive utilisant uniquement la fonction. Il juge s'il s'agit d'un fichier ou d'un dossier, et s'il s'agit d'un dossier, il appelle à nouveau de manière récursive.

fin

Récemment, je me suis souvenu d'une récidive et j'ai essayé diverses choses. Il est préférable d'utiliser l'analyse syntaxique pour les expressions régulières, et ce n'est pas pratique car vous pouvez obtenir le nom du fichier avec pathlib.Path (). Glob ...