Comparação de múltiplas listas Python

Question

Eu tenho um código que tem três listas e ele compara o índice da segunda lista com o índice da primeira, desde que a primeira lista tenha seis elementos. O código então será acrescentado à terceira lista se parte de uma string corresponder ao índice da primeira lista. Se a string não corresponder, ele anexará uma mensagem. Espero encontrar uma maneira melhor e mais pitônica de escrever meu algoritmo. Aqui está o meu código:

L1 = ["first = 1st","second = 2nd","third = 3rd","fourth = 4th","sixth = 6th",
  "first = A","second = B","third = C","fifth = E","sixth = F",
  "second = W","third = X","fourth = Y","fifth = Z","sixth = AA","first = BB"]
L2 = ["first","second","third","fourth","fifth","sixth"]
L3 = []

#Used in case a list has less than six elements
if len(L1) % 6 != 0:
    L1.append("Missing_Data")

c = 0
for i in L1:
    cont = True
    while cont:
        if L2[c] in i:
            L3.append(i.split("= ")[-1])
            c += 1
            if c < len(L2):
                cont = False
            else:
                c = 0
                cont = False
        else:
            L3.append("Missing_Data")
            c += 1
            if c < len(L2):
                continue
            else:
                c = 0
                break

Este código funciona para o que eu quero, mas acho que é muito longo. Qualquer ajuda em tornar este código mais Pythônico seria muito apreciada. Desde já, obrigado.

Answer 1

Minha revisão do seu código atual é fácil de resumir: é muito complicado e faz minha cabeça doer . Mas não se sinta mal, porque você está em ótima companhia. As primeiras tentativas costumam ser assim - mesmo para pessoas que já fazem isso há muito tempo.

O que, especificamente, o torna difícil de entender? Complexidade algorítmica: loops aninhados e condicionais, quebras, gerenciamento de índices de lista e assim por diante. Sempre que você percebe esse tipo de complexidade, geralmente ajuda a considerar se uma estrutura de dados mais poderosa simplificaria a situação (estou usando "estrutura de dados" em um sentido muito amplo). Na reescrita oferecida abaixo, usaremos um iterável especial que nos permite espiar o próximo valor sem realmente consumi-lo todas as vezes. Essa mudança simplifica drasticamente a contabilidade dentro do loop principal e também simplifica como anexamos o restante dos valores ausentes após sairmos do loop.

# This is a third party library that is worth knowing about.
from more_itertools import peekable

# Your data, aligned so we can see what is going on.
# When you ask a question, it's a good idea to help your helpers.
xs = [
    'first = 1st', 'second = 2nd', 'third = 3rd', 'fourth = 4th',              'sixth = 6th',
    'first = A',   'second = B',   'third = C',                   'fifth = E', 'sixth = F',
                   'second = W',   'third = X',   'fourth = Y',   'fifth = Z', 'sixth = AA',
    'first = BB',
]

ys = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']

# Python has a builtin concept for missing data. Use it if you can.
# If you cannot, define a constant.
MISSING = None

# The results we want.
# When you ask a question, it's a good idea to provide this.
EXPECTED = [
    '1st',     '2nd',     '3rd',     '4th',     MISSING,   '6th',
    'A',       'B',       'C',       MISSING,   'E',       'F',
    MISSING,   'W',       'X',       'Y',       'Z',       'AA',
    'BB',      MISSING,   MISSING,   MISSING,   MISSING,   MISSING
]

# We will use a peekable iterable for both the Xs and the Ys.
xit = peekable(xs)
yit = None
results = []

# Process all Xs to build the results.
# A Y is consumed each time, and we get a fresh Ys iterable as needed.
# We consume an X only when current X and Y agree.
while xit:
    yit = yit or peekable(ys)
    x = xit.peek()
    y = next(yit)
    val = next(xit).split('= ')[-1] if y in x else MISSING
    results.append(val)

# The results should always contain a full cycle of Ys.
results.extend(MISSING for _ in yit)

# Check.
print(results == EXPECTED)

Answer 2

if c < len(L2):
    continue
else:
    c = 0
    break

Como continuesempre acontece no final de um loop, você pode reverter essas condições para torná-lo mais curto.

if c >= len(L2):
    c = 0
    break

agora você não precisa, elsepois nada mais do que a condição de interrupção será continueautomaticamente.

Mais acima onde você definir cont = False, você poderia usar em breakvez disso, tanto quanto eu posso dizer. Isso elimina conttotalmente a necessidade de fazerwhile True:

Answer 3

Estou respondendo principalmente em SO, então minha resposta pode não estar seguindo PEP8 ou outras diretrizes, mas tentei fazer uma versão do seu código que seja mais fácil de ver o que está acontecendo, sem ifs, quebras, continua e tendo uma contagem de linha menor:

length = len(L2)
missing = 'Missing_Data'
index = -1

for item in L1:
    key,value = item.split(' = ')
    current = L2.index(key)
    no_missing = (current-index)%length-1 # get number of missing elements
    L3 += [missing] * no_missing # append this many of the missing value
    L3.append(value) # append current value
    index = current
    
L3 += [missing] * (length-index-1) # fill rest of list with missing elements