2
votes

Créer une fonction qui s'incrémentera de un lorsqu'elle sera appelée

J'ai besoin d'une fonction qui s'incrémentera de un à chaque fois qu'elle sera appelée. J'ai utilisé le compte, mais chaque fois que je le fais, il réinitialise le compte à la valeur d'origine plus un compte. J'ai vu beaucoup de code mais rien de tout cela ne fonctionne. Voici ce que j'ai maintenant

J'ai beaucoup étudié les boucles et les itérations

def count_row():
    count = 1  
    while count >= 1:
        yield count
        count += 1 
return count

python count

4 commentaires

Pour que count renvoie +1 à chaque appel, il doit "se souvenir" de la dernière valeur. Ou en d'autres termes, vous avez besoin d'un état partagé entre les appels. est-ce que cela aide?

Oui, c'est parfaitement logique, mais je ne sais tout simplement pas comment faire cela.

Qu'est-ce que cette fonction fait d'autre que retourner un nombre toujours croissant? Vous voudrez peut-être consulter la fonction enumerate , qui vous permet de coupler un nombre croissant avec une valeur d'un itérateur. enumerate (some_list) est à peu près le même que zip (range (0, len (some_list)), some_list) .

L'idée est de l'utiliser avec xlwings pour parcourir les lignes Excel et en fonction de la valeur de la cellule, d'utiliser une formule pour insérer des données.

4 Réponses :

-1
votes

si j'ai bien compris, cela devrait fonctionner:

count=0
def count_row(count): 
    count += 1 
    return count

2 commentaires

J'appelle le coun_row () plus tard et j'obtiens une erreur indiquant qu'il manque 1 nombre d'arguments positionnels requis

@nmhammer vous devriez l'appeler comme ceci ¨count row (count) ¨ et vous avez probablement appelé comme ceci ¨count_row () ¨

0
votes

Vous pouvez utiliser un générateur ici qui incrémente la valeur de un à chaque fois qu'il est appelé en utilisant next():

def count_row():
    count = 0
    while True:
        count += 1
        yield count

itr = count_row()

print(next(itr))  # 1
print(next(itr))  # 2

Si vous regardez de près, cela équivaut à ce que itertools.count () a > fait.

0 commentaires

4
votes

Vous pouvez utiliser itertools.count.

class CallableCount(count):
    def __call__(self):
        return next(self)

counter = CallableCount(1)

counter() # 1
counter() # 2

Fonction avec état

Si vous voulez absolument une fonction avec état au lieu d'appeler suivant , vous pouvez envelopper le count dans une fonction.

def counter(_count=count(1)):
    return next(_count)

counter() # 1
counter() # 2

Classe

Alternativement, itertools.count étant une classe, vous pouvez en hériter pour étendre son comportement et en faire un appelable.

from itertools import count

counter = count(1)
next(counter) # 1
next(counter) # 2

L'utilisation d'une classe devrait être votre approche préférée car elle permet d'instancier plusieurs compteurs.

5 commentaires

Êtes-vous sûr d'appeler ce code exact? Si oui, quelle est votre version de Python?

Oui, j'ai copié et collé pour m'en assurer. Python 3.7.1

@nmhammer Cela fonctionne à la fois sur Python 3.6 et 3.7. Vous n'exécutez probablement pas le script que vous recherchez ou vous n'avez pas importé itertools.count et utilisez une autre valeur nommée count. Voir ce repl: repl.it/@omelancon/callableCounter

voici la dernière tentative repl.it/@nmhammer2/LustedDeliriousNamebinding . J'utilise ce code avec xlwings.

@nmhammer crée le compteur en dehors de la fonction xl_time_cap, sinon un nouveau est créé à chaque fois que vous appelez la fonction. De plus, votre code ne fonctionne tout simplement pas sur repl.

2
votes

Vous avez besoin d'une fermeture. Définissez une fonction make_counter qui initialise une variable locale, puis définit et renvoie une fonction qui incrémente cette variable à chaque appel.

>>> count_row = Count()
>>> count_row()
0
>>> count_row()
1

Maintenant count_row code > renverra une nouvelle valeur à chaque appel:

class Count:
    def __init__(self):
        self.count = -1

    def __call__(self):
        self.count += 1
        return count

C'est une sorte de duel d'une classe. Vous avez une fonction qui "enveloppe" certaines données ( ferme sur la variable), au lieu d'une donnée avec une méthode associée. La version de la classe; notez la similitude avec make_counter:

>>> count_row()
0
>>> count_row()
1

Une instance de cette classe se comporte désormais comme notre fermeture précédente.

def make_counter():
    count = -1
    def _():
        count += 1
        return count
    return _

count_row = make_counter()

0 commentaires