Получение противоречивого вывода между двумя методами обращения к списку

Question

Я пытаюсь запустить программу противовеса. Я не могу понять, что делает Python, чтобы получить вывод, который я получаю. У меня 8 вариантов из 16 карт. Варианты определяются timingConditions * distractionConditions, Есть четыре ключевых части начальных определений переменных:

1. inst список, содержащий все 8 вариантов * 16 экспериментальных карт, упорядоченных по вариантам (карты буквально похожи на карту видеоигр). Это оставляет len(inst) = 128,
2. inst подразделяется на 8 conds, Каждый из этих подсписков представляет карты 1-16 определенного варианта. Каждый индекс в подсписке представляет одну комбинацию карты / варианта. Вызов индекса каждого подсписка в conds покажет вам это ясно.

3. 16 карт разбиты на 8 списков, содержащих по две карты каждый, определенные в переменной MapGroups, Эти 8 списков предназначены для использования в матрице ниже.

4. counterBalanceMatrix представляет восемь уникальных сбалансированных порядков карт для назначения условий. Каждый предмет в range(1,9) назначен на одну из этих строк. Числа в строке представляют группы карт. Столбцы (то есть упорядочение по индексу) представляют назначение варианта группе карт. Например, counterBalanceMatrix[0][0] возвращается 1, первый индекс соответствует присвоению первого варианта столбца SSTrue; а второй индекс соответствует MapGroups[0] (который будет возвращать "0", "15"). Следовательно, желаемым выходным сигналом будут карты 0 и 15 (или 1 и 16 без упорядочения на основе нуля), которым присвоен SS-True. Вы можете изобразить это следующим образом:

           ####+--------+--------+--------+--------+---------+---------+---------+---------+
           ####| SSTrue | SLTrue | LSTrue | LLTrue | SSFalse | SLFalse | LSFalse | LLFalse |
           ####+--------+--------+--------+--------+---------+---------+---------+---------+
           ####|      1 |      2 |      3 |      4 |       5 |       6 |       7 |       8 |
           ####|      2 |      3 |      4 |      5 |       6 |       7 |       8 |       1 |
           ####|      3 |      4 |      5 |      6 |       7 |       8 |       1 |       2 |
           ####|      4 |      5 |      6 |      7 |       8 |       1 |       2 |       3 |
           ####|      5 |      6 |      7 |      8 |       1 |       2 |       3 |       4 |
           ####|      6 |      7 |      8 |      1 |       2 |       3 |       4 |       5 |
           ####|      7 |      8 |      1 |      2 |       3 |       4 |       5 |       6 |
           ####|      8 |      1 |      2 |      3 |       4 |       5 |       6 |       7 |
           ####+--------+--------+--------+--------+---------+---------+---------+-----  ----+
   

Ожидаемый вывод кода ниже, чем для subject in range(1,9):будет один экземпляр каждого MapGroupи два наблюдения каждого варианта (например, SS-TRUE, LL-False и т. д.). По всем предметам будут равные наблюдения всех MapGroups и варианты. Эта часть кода работает как положено.

import re
timingConditions = ["SS","SL","LS","LL"]
distractionConditions = ["True","False"]
maps = [i for i in range(1,17)]

#This loop sets up the 128 (16*8) variants. Inst for instances of scenario.
inst = []
for d in distractionConditions:
    for t in timingConditions:
        for map in maps:
            inst.append(str(str(map)+"-"+t+"-"+d))

conds = [inst[0:16],inst[16:32],inst[32:48],inst[48:64],inst[64:80],inst[80:96],inst[96:112],inst[112:128]]

MapGroups= [[0,8],
[1,9],
[2,10],
[3,11],
[4,12],
[5,13],
[6,14],
[7,15]]

counterBalanceMatrix= [[1,2,3,4,5,6,7,8],
[2,3,4,5,6,7,8,1],
[3,4,5,6,7,8,1,2],
[4,5,6,7,8,1,2,3],
[5,6,7,8,1,2,3,4],
[6,7,8,1,2,3,4,5],
[7,8,1,2,3,4,5,6],
[8,1,2,3,4,5,6,7]]

for subject in range(1,9):
    cRow = counterBalanceMatrix[(subject-1)%8]#Use the modulus operator to find out which row to use in counterbalancing for this subject.
    scenArray = []

    for group in range(0,8):#This loops across map groups and look up their assigned interruption condition
        scenArray.extend([conds[cRow[group]-1][i] for i in MapGroups[group]]) 
        print "****","Participant",subject,"Correct Day 1****"
        print scenArray
        print "\n\n"

Вот в чем проблема: я хочу повторить эту процедуру, но с зеркалом. То есть, какой бы ни был вариант каждого list in MapGroups был назначен изначально, я хочу, чтобы он был инвертирован (например, если вы получили MapGroups[0] как Истина, тогда я хочу, чтобы они были Ложными. MapGroups[0] был назначен СС, теперь он должен быть LL.

Моим первоначальным решением было обратить вспять counterBalanceMatrix и примените ту же петлю. Однако это не сработало:

counterBalanceMatrixReverse= []
for list in counterBalanceMatrix:
    counterBalanceMatrixReverse.append(list[::-1])

###And then run the exact same loop over.
for subject in range(1,9):
    cRow = counterBalanceMatrixReverse[(subject-1)%8]
#
    scenArray = []
    for group in range(0,8):
        scenArray.extend([conds[cRow[group]-1][i] for i in MapGroups[group]])
        print "****","Participant",subject,"Broken Reversed 2****"
        print scenArray
        print "\n\n" 

Вывод неверный, например:

>Participant 4 
>'2-SL-True', '10-SL-True'
Participant 4 Reversed
>'2-SS-False', '10-SS-False'
Exptected Reversed Ouput:
>'2-LS-False', '10-LS-False'

Тем не менее, простой реверсивный массив cond решает мою проблему

condsreverse = []
condsreverse.extend(conds[::-1])

for subject in range(1,9):
    cRow = counterBalanceMatrix[(subject-1)%8]#Note I use same matrix
    scenArray = []
    for group in range(0,8):
        scenArray.extend([condsreverse[cRow[group]-1][i] for i in MapGroups[group]]) 
    print "****","Subject",subject,"Correct Reverse****"
    print scenArray
    print "\n\n"

Я сидел на этом в течение трех дней, и я не могу понять, почему первоначальное реверсивное решение не дает желаемого результата.

Answer 1

Я полагаю, что решение заключается в следующем, хотя бы с целью закрытия вопроса.

Моя ошибка заключалась в том, что я принял на себя [conds[cRow[group]-1] назначал вариант на основе индекса cRow[i] и cRow[i] просто используется для вызова конкретных карт. Однако на самом деле присваивается вариант на основе значения cRow[i], Следовательно, "столбцы" не были назначены MapGroups на основе индексации. Это означает, что просто поменять местами counterBalanceMatrix в основном просто создает другую версию counterBalanceMatrix,

Единственный способ получить условия для отражения друг друга - это поменять порядок conds потому что это список, который фактически используется в назначении; если, конечно, я не хотел изменить scenArray.extend([condsreverse[cRow[group]-1][i] for i in MapGroups[group]]) вызвать индекс каждого элемента (как для исходного, так и для обратного), а затем на основе этого индекса вызвать группу карт следующим образом:

for index in range(0,8):
    scenArray.extend([conds[index][i] for i in MapGroups[cRow[index]-1]])

PS: я думаю, что написать это как вопрос помог мне понять мою ошибку. Извини за это.