Les variables globales de la récursivité. Python

OK, je suis en utilisant Python 2.7.3 et voici mon code:

def lenRecur(s): 

    count = 0

    def isChar(c):
        c = c.lower()
        ans=''
        for s in c:
            if s in 'abcdefghijklmnopqrstuvwxyz':
                ans += s
        return ans

    def leng(s):
        global count
        if len(s)==0:
            return count
        else:
            count += 1
            return leng(s[1:])

    return leng(isChar(s))

Je suis en train de modifier la variable count à l'intérieur de la leng fonction. Voici les choses que j'ai essayé:

Si j'ai mis la variable de comptage à l'extérieur de la lenRecur de la fonction, il fonctionne très bien la première fois, mais si je tente de nouveau sans avoir à redémarrer python shell, le comte (évidemment) ne redémarre pas, il ne cesse d'ajouter de.
Si je change le count += 1 ligne pour count = 1 il fonctionne également, mais la sortie est (évidemment).

Donc, mon but ici est d'obtenir la longueur de la chaîne en utilisant la récursivité, mais je ne sais pas comment faire pour garder une trace du nombre de lettres. J'ai cherché de l'information sur des variables globales, mais je suis toujours bloqué. Je ne sais pas si je ne l'ai pas compris, ou encore si j'ai un problème dans mon code.

Merci d'avance!

ne pouvez pas voir la récursivité lui-même.
Désolé, maintenant, c'est ok!

OriginalL'auteur Carles Mitjans | 2013-06-27

15

count dans lenRecur est pas mondiale. C'est une étendue variable.

Vous aurez besoin d'utiliser Python 3 avant que vous pouvez faire que le travail de cette façon; vous êtes à la recherche pour le non déclaration ajouté à Python 3.

En Python 2, vous pouvez contourner cette limitation en utilisant une mutable (comme une liste) pour count à la place:
```
def lenRecur(s): 

    count = [0]

    # ...

    def leng(s):
        if len(s)==0:
            return count[0]
        else:
            count[0] += 1
            return lenIter(s[1:])
```
Maintenant vous n'êtes plus en altérer la count nom lui-même; il reste le même, il garde en se référant à la même liste. Tout ce que vous faites est en train de modifier le premier élément contenues dans le count liste.

Une alternative "orthographe" serait de faire count une fonction d'attribut:
```
def lenRecur(s): 

    # ...

    def leng(s):
        if len(s)==0:
            return leng.count
        else:
            leng.count += 1
            return lenIter(s[1:])

    leng.count = 0
```
Maintenant count n'est plus local à lenRecur(); il est devenu un attribut sur le immuable lenRecur() fonction de la place.

Pour votre problème spécifique, vous êtes réellement avoir à y penser les choses. Juste la récursivité de faire la synthèse:
```
def lenRecur(s):
    def characters_only(s):
        return ''.join([c for c in s if c.isalpha()])

    def len_recursive(s):
        if not s:
            return 0
        return 1 + len_recursive(s[1:])

    return len_recursive(characters_only(s))
```
Démo:
```
>>> def lenRecur(s):
...     def characters_only(s):
...         return ''.join([c for c in s if c.isalpha()])
...     def len_recursive(s):
...         if not s:
...             return 0
...         return 1 + len_recursive(s[1:])
...     return len_recursive(characters_only(s))
... 
>>> lenRecur('The Quick Brown Fox')
16
```
Est-il possible de le faire en Python 2.7?
ou Vous pouvez passer le comte comme un paramètre à leng fonction
Ok qui a fonctionné pour moi! Puis-je vous demander pourquoi une liste de travail et pas une variable normale?
I pense j'ai eu une longueur d'avance de vos questions jusqu'à présent, je l'ai montée dans une explication des raisons pour lesquelles count = [0] œuvres; avez-vous vu déjà?
Oui oui!! Merci beaucoup! C'est ce que j'appelle une bonne réponse 🙂

OriginalL'auteur Martijn Pieters
6

Je pense que Vous pouvez passer le comte comme deuxième argument
```
def anything(s):
    def leng(s, count):
        if not s:
            return count
        return leng(s[1:], count + 1)

    return leng(isChar(s), 0)
```
cela devrait fonctionner mieux que l'inhibition des objets de l'extérieur de la portée telles que l'utilisation d'objets mutables (list ou dict) ou le singe de correction de la fonction elle-même par exemple.

Ouch! Ne pense pas à ce sujet. Merci!
J'ai posté la même réponse. N'ai pas vu votre message. Je suppose que je suis en retard comme d'habitude 🙂
Vous feriez mieux de voter pour ma solution au lieu de commenter 😉

OriginalL'auteur oleg
1

Vous avez besoin pour faire de la variable de comptage d'une variable de fonction comme
```
def lenRecur(s):
    lenRecur.count = 0
```
Cependant, je vois quelques problèmes avec le code.

1) Si vous essayez de trouver le nombre de lettres de l'alphabet une chaîne de caractères grâce à la récursivité, ce n':
```
def lenRecur(s):
    def leng(s, count = 0):
            if not s:
                    return count
            else:
                    count += int(s[0].isalpha())
                    return leng(s[1:], count)
    return leng(s)
```
Encore, mais je préfère avoir une seule fonction pour faire la tâche, comme il n'y aura pas de leng méthode à tous.

2) Si votre but est juste de trouver le nombre de lettres de l'alphabet d'une chaîne, je préfère compréhension de liste
```
def alphalen(s):
    return sum([1 for ch in s if ch.isalpha()])
```
Si c'est autre chose que de l'objet de l'apprentissage, je vous suggère d'éviter la récursivité. Parce que, la solution ne peut pas être utilisé pour les grandes chaînes(disons, de trouver l'alphabet comptent à partir du contenu d'un fichier). Vous pourriez frapper la RunTimeError de Profondeur Maximum de Récursivité Dépassé.

Même si vous pouvez contourner ce à travers le réglage de la profondeur de récursivité par setrecursionlimit fonction, je vous suggère de passer par d'autres moyens faciles. Plus d'informations sur le réglage de la recursionlimit ici.

OriginalL'auteur thiruvenkadam
0

Définir en dehors de toutes les définitions de fonctions, si vous voulez l'utiliser comme une variable globale:
```
count = 0
def lenRecur(s): 
```
ou le définir comme une fonction d'attribut:
```
def lenRecur(s): 
    lenRecur.count = 0
    def isChar(c):
```
Cela a été corrigé dans py3.x où vous pouvez utiliser le nonlocal déclaration:
```
def leng(s):
    nonlocal count
    if len(s)==0:
```
Si je difine à l'extérieur de la fonction lenRecur est la première déclaration, j'ai dit que j'ai essayé. Merci quand même!
Je suppose que j'ai loupé ce détail, Vous pouvez le définir comme une fonction d'attribut.
Ne vous inquiétez pas 🙂 merci pour la réponse!

OriginalL'auteur Ashwini Chaudhary

Vous n'avez pas besoin de compter. Le dessous de la fonction de travail.


    def leng(s):
        if not s:
            return 0
        return 1 + leng(s[1:])

Également travaillé! Merci!!

OriginalL'auteur Atmaram Shetye

Vous devez vous connecter pour publier un commentaire.