Das Konzept hinter dem Produkt von itertool Funktion

Question

Also grundsätzlich möchte ich das Konzept der product() - Funktion in iwertools verstehen. Ich meine, was ist der Unterschied zwischen Rendite und Rendite? Und kann dieser Code sowieso verkürzt werden?

def product1(*args, **kwds): 
     pools = map(tuple, args) * kwds.get('repeat', 1) 
     n = len(pools) 
     if n == 0: 
      yield() 
      return 
     if any(len(pool) == 0 for pool in pools): 
      return 
     indices = [0] * n 
     yield tuple(pool[i] for pool, i in zip(pools, indices)) 
     while 1: 
      for i in reversed(range(n)): # right to left 
       if indices[i] == len(pools[i]) - 1: 
        continue 
       indices[i] += 1 
       for j in range(i+1, n): 
        indices[j] = 0 
       yield tuple(pool[i] for pool, i in zip(pools, indices)) 
       break 
      else: 
       return 

Answer 1

Dieser Code sollte die Arbeit machen:

bytes = [i for i in range(2**(n))] 
AB= [] 
for obj in bytes: 
    t = str(bin(obj))[2:] 
    t= '0'*(n-len(t)) + t 
    AB.append(t.replace('0','A').replace('1','B')) 

n Wesen die gewünschte Zeichenkettengröße

Answer 2

Ich würde empfehlen, die gut etabliert mit und getestet itertoolsstandard module. Das Rad neu zu erfinden ist nie ratsam als Programmierer. Das heißt, ich würde mit einem Blick auf die product() Funktion in Iwertools beginnen.

Wie für nicht itertools() Verwendung dieses Problem ist im wesentlichen ein kartesisches Produkt Problem (n-Permutationen mit Dubletten erlaubt). Hier hilft uns die Rekursion! Eine mögliche Lösung unter:

Methode Körper:

result = [] 
def permutations(alphabet, repeat, total = ''): 
    if repeat >= 1: 
     for i in alphabet: 
      # Add the subsolutions.  
      permutations(alphabet, repeat - 1, total + i) 

    else: 
     result.append(total) 
    return result 

Und wenn wir rufen mit permutations()

Beispiel Ausgänge:

permutations('ab', 3) -> 
$ ['aaa', 'aab', 'aba', 'abb', 'baa', 'bab', 'bba', 'bbb'] 
permutations('ab', 3) -> 
$ ['aaa', 'aab', 'aac', 'aba', 'abb', 'abc', 'aca', 'acb', 'acc', 'baa', 
    'bab', 'bac', 'bba', 'bbb', 'bbc', 'bca', 'bcb', 'bcc', 'caa', 'cab', 
    'cac', 'cba', 'cbb', 'cbc', 'cca', 'ccb', 'ccc'] 
permutations('ab', 1) -> 
$ ['a', 'b'] 

Wie funktioniert es?

Diese Methode funktioniert, indem Schleifen für rekursiv verschachtelt wiederholen -times. Wir akkumulieren dann das Ergebnis der Unterlösungen und hängen es an eine Ergebnisliste an. Also, wenn wir als unsere Wiederholungswert verwenden, erweitert out iterative Spur dieses Problem wie folgt aussehen würde:

for i in alphabet: 
    for j in alphabet: 
     for k in alphabet: 
      for l in alphabet: 
       result.append(i + j + k + l) 

Answer 3

Erstellen Sie zuerst eine Liste mit allen möglichen Anordnungen, die einfach durch das Summieren von Binärdateien erreicht werden kann:

Die [2:] schneidet die Zeichenfolge und entfernt '0b' daraus und zfill (n) vervollständigt die Zeichenfolge mit 0s, bis die Zeichenfolge die Länge von n hat.

nun alle 0,1 von A, B ersetzen jeweils:

arrangements = [arrangement.replace('0', 'A').replace('1', 'B') for arrangement in generate_arrangements(3)] 
print(arrangements) 
>> ['AAA', 'AAB', 'ABA', 'ABB', 'BAA', 'BAB', 'BBA', 'BBB'] 

Wenn Sie alle zusammen setzen wollen Sie haben:

def generateAB(n): 
    arrangements = [bin(i)[2:].zfill(n) for i in range(2**n)] 
    return [arrangement.replace('0', 'A').replace('1', 'B') for arrangement in arrangements]