Mam poniżej 3 oddzielne funkcje, których używam w różnych miejscach mojego kodu zgodnie z ich kategorią. Zasadniczo chcę wygenerować inną numerację sekwencyjną. Wywołanie mojej funkcji „AppleNum” zaczyna się od 002, jak pokazano poniżej, i innej numeracji sekwencji dla funkcji „BananaNum” (zaczyna się od 005) i tak dalej.

Moje pytanie brzmi, jak umieścić te 3 oddzielne funkcje w pojedynczej funkcji lub klasie, aby dzwoniąc do „Apple” otrzymywałem numery zwiększane od 002, a jeśli dzwonię do „Orange”, otrzymuję numery zwiększane od 009 .. (również jeśli są dowolna możliwość ustawienia maksymalnej liczby dla licznika, tak aby startował od wartości minimalnej.

Apple = 2
def AppleNum():
    global Apple
    Apple += 1
    return str(Apple).zfill(3)

Banana = 5
def BananaNum():
    global Banana
    Banana += 1
    return str(Banana).zfill(3)

Orange = 9
def OrangeNum():
    global Orange
    Orange += 1
    return str(Orange).zfill(3)

Expected output:

Imagine a single function that have all above, and if call `function(Apple)` --> gives 003, and increments starts from there.

at same time if i call `function(Orange)` ---> gives 010 and increment starts from there.

To tylko przykładowy kod, w moim oryginalnym fragmencie kodu mam 12-15 kategorii. Dlatego nie chcę pisać 12 oddzielnych funkcji.

Proszę pomóż mi..

(Doceń twoją pomoc, jeśli istnieje możliwość ustawienia maksymalnej liczby, to znaczy, jeśli licznik osiągnie 9999, licznik ponownie startuje od ich minimalnej liczby.)

Z góry dziękuję.

-4
Maria628 1 kwiecień 2020, 21:23

5 odpowiedzi

Najlepsza odpowiedź

Możesz użyć dyktu do przechowywania swoich funkcji:

my_f = {'Apple': AppleNum, 'Orange': OrangeNum, 'Banana' :OrangeNum}

def fruits(fruit):
    return my_f[fruit]()

Oto lepszy sposób na ustawienie licznika na maksimum 999:

from itertools import cycle
from collections import defaultdict

count = defaultdict(lambda : cycle(range(1000)))

def fruits(f):
    return f'{next(count[f])}'.zfill(3)

Każdy owoc użyty z funkcją fruits zostanie automatycznie zarejestrowany i będzie miał maksymalny licznik 999, po osiągnięciu maksymalnej wartości licznik zostanie ponownie przetworzony do 0

Jeśli chcesz ustawić wartości minimalne, możesz użyć:

from itertools import cycle

count = {'Apple': cycle(range(2,1000)),  'Banana': cycle(range(5,1000)), 'Orange': cycle(range(9,1000))}
def fruits(f):
    return f'{next(count[f])}'.zfill(3)
1
kederrac 1 kwiecień 2020, 19:14

Używając klasy z nazwą i domyślnymi wartościami min i max

class FruitCounter():
  def __init__(self, name, begin = 0, max_count = 9999):
    self.name = name
    self.count = begin
    self.max_count = max_count

  def incr(self):
    if self.count <= self.max_count:
      self.count += 1
    return str(self.count).zfill(3)

  def __str__(self):
    return self.name

Testuj

# Instantiate fruit in loop and increment
for fruit in [FruitCounter('Apple', 2, 4), FruitCounter('Banana', 5, 7), FruitCounter('Orange', 9)]:
  for i in range(10):
    print(f'Incrementing {fruit} {fruit.incr()}')

Wyjście

Incrementing Apple 003
Incrementing Apple 004
Incrementing Apple 005
Incrementing Apple 005
Incrementing Apple 005
Incrementing Apple 005
Incrementing Apple 005
Incrementing Apple 005
Incrementing Apple 005
Incrementing Apple 005
Incrementing Banana 006
Incrementing Banana 007
Incrementing Banana 008
Incrementing Banana 008
Incrementing Banana 008
Incrementing Banana 008
Incrementing Banana 008
Incrementing Banana 008
Incrementing Banana 008
Incrementing Banana 008
Incrementing Orange 010
Incrementing Orange 011
Incrementing Orange 012
Incrementing Orange 013
Incrementing Orange 014
Incrementing Orange 015
Incrementing Orange 016
Incrementing Orange 017
Incrementing Orange 018
Incrementing Orange 019
1
DarrylG 1 kwiecień 2020, 19:25

To jest naprawdę proste. Oto najprostszy sposób na zrobienie tego:

Apple = 2
Banana = 5
Orange = 9

def fn(case):
  global Apple, Banana, Orange

  if case == "Apple":
    Apple += 1
    return str(Apple).zfill(3)
  elif case == "Banana":
    Banana += 1
    return str(Banana).zfill(3)
  elif case == "Orange":
    Orange += 1
    return str(Orange).zfill(3)
  return

Aby uzyskać maksimum, po prostu dołącz pewne stałe zmienne „oryginalna wartość”, a następnie sprawdź, czy jakakolwiek wartość jest większa niż maksymalna, kiedy ją zwiększasz, a następnie zresetuj, jeśli tak jest.

0
manny 1 kwiecień 2020, 18:27

Na podstawie tego, co powiedziałeś, powinno to załatwić sprawę

Apple = 2
Orange = 9
Banana = 5
def fruit_inc(fruit):
    global Apple, Orange, Banana
    if fruit == "Apple":
        Apple += 1
        return str(Apple).zfill(3)
    elif fruit == "Orange":
        Orange += 1
        return str(Orange).zfill(3)
    elif fruit == "Banana":
        Banana += 1
        return str(Banana).zfill(3)
    else:
        print("Fruit is invalid")
0
unkn0wn.dev 1 kwiecień 2020, 18:39

Możesz zdefiniować klasę o nazwie Fruit (na przykład), a następnie utworzyć instancję różnych owoców:

class Fruit():
    amount = 0
    index = ''
    def increment(self):
        self.amount += 1
        self.index = str(self.amount).zfill(3)

banana = Fruit()
banana.increment()

apple = Fruit()
apple.increment()
apple.increment()
apple.increment()

print (banana.index, 'bananas') # prints 001 bananas
print (apple.index, 'apples')   # prints 003 apples
0
m8factorial 1 kwiecień 2020, 18:43