Сервер вернул код ответа HTTP: 400 для URL: Java.IO.Exception [duplicate]

TLDR:

Я написал библиотеку, которая позволяет вам это сделать:

from fluidIter import FluidIterable
fSomeList = FluidIterable(someList)  
for tup in fSomeList:
    if determine(tup):
        # remove 'tup' without "breaking" the iteration
        fSomeList.remove(tup)
        # tup has also been removed from 'someList'
        # as well as 'fSomeList'

Лучше всего использовать другой метод, если это возможно, что не требует модификации вашего итерации во время итерации по нему, но для некоторых алгоритмов это может быть не так прямо. И если вы уверены, что действительно хотите шаблон кода, описанный в исходном вопросе, это возможно.

Должно работать во всех изменяемых последовательностях, а не только в списках.

Полный ответ:

Изменить: последний пример кода в этом ответе дает пример использования для , почему вы иногда можете изменить список на месте, а не использовать понимание списка. Первая часть ответов служит в качестве учебника , как массив может быть изменен на месте.

Решение следует из этого ответа (для относящийся вопрос) из senderle. Это объясняет, как обновляется индекс массива при повторении через список, который был изменен. Ниже приведено решение правильно отслеживать индекс массива, даже если список изменен.

Загрузите fluidIter.py из здесь https://github.com/alanbacon/FluidIterator, это всего лишь один файл, поэтому нет необходимо установить git. Нет инсталлятора, поэтому вам нужно убедиться, что файл находится на пути python. Код был написан для python 3 и не проверен на python 2.

from fluidIter import FluidIterable
l = [0,1,2,3,4,5,6,7,8]  
fluidL = FluidIterable(l)                       
for i in fluidL:
    print('initial state of list on this iteration: ' + str(fluidL)) 
    print('current iteration value: ' + str(i))
    print('popped value: ' + str(fluidL.pop(2)))
    print(' ')

print('Final List Value: ' + str(l))

Это приведет к следующему выводу:

initial state of list on this iteration: [0, 1, 2, 3, 4, 5, 6, 7, 8]
current iteration value: 0
popped value: 2

initial state of list on this iteration: [0, 1, 3, 4, 5, 6, 7, 8]
current iteration value: 1
popped value: 3

initial state of list on this iteration: [0, 1, 4, 5, 6, 7, 8]
current iteration value: 4
popped value: 4

initial state of list on this iteration: [0, 1, 5, 6, 7, 8]
current iteration value: 5
popped value: 5

initial state of list on this iteration: [0, 1, 6, 7, 8]
current iteration value: 6
popped value: 6

initial state of list on this iteration: [0, 1, 7, 8]
current iteration value: 7
popped value: 7

initial state of list on this iteration: [0, 1, 8]
current iteration value: 8
popped value: 8

Final List Value: [0, 1]

Выше мы использовали pop метод на объекте списка текучей среды. Также применяются другие обычные итерационные методы, такие как del fluidL[i], .remove, .insert, .append, .extend. Список также может быть изменен с использованием срезов (методы sort и reverse не реализованы).

Единственное условие состоит в том, что вы должны только модифицировать список на месте, если в любой точке fluidL или l были переназначены в другой объект списка, код не будет работать. Исходный объект fluidL все равно будет использоваться циклом for, но он будет недоступен для изменения.

ie

fluidL[2] = 'a'   # is OK
fluidL = [0, 1, 'a', 3, 4, 5, 6, 7, 8]  # is not OK

Если мы хотим получить доступ к текущему значение индекса списка, которое мы не можем использовать, перечисляет, так как это только подсчитывает, сколько раз цикл for был запущен. Вместо этого мы будем использовать объект итератора напрямую.

fluidArr = FluidIterable([0,1,2,3])
# get iterator first so can query the current index
fluidArrIter = fluidArr.__iter__()
for i, v in enumerate(fluidArrIter):
    print('enum: ', i)
    print('current val: ', v)
    print('current ind: ', fluidArrIter.currentIndex)
    print(fluidArr)
    fluidArr.insert(0,'a')
    print(' ')

print('Final List Value: ' + str(fluidArr))

Это выведет следующее:

enum:  0
current val:  0
current ind:  0
[0, 1, 2, 3]

enum:  1
current val:  1
current ind:  2
['a', 0, 1, 2, 3]

enum:  2
current val:  2
current ind:  4
['a', 'a', 0, 1, 2, 3]

enum:  3
current val:  3
current ind:  6
['a', 'a', 'a', 0, 1, 2, 3]

Final List Value: ['a', 'a', 'a', 'a', 0, 1, 2, 3]

Класс FluidIterable просто предоставляет оболочку для исходного объекта списка. К исходному объекту можно обращаться как к свойству жидкого объекта, например:

originalList = fluidArr.fixedIterable

Дополнительные примеры / тесты можно найти в разделе if __name__ is "__main__": внизу fluidIter.py. Это стоит посмотреть, потому что они объясняют, что происходит в разных ситуациях. Например: Замена больших разделов списка с помощью среза. Или используя (и изменяя) то же самое итерабельное в вложенных циклах.

Как я уже сказал, это сложное решение, которое повредит читабельности вашего кода и затруднит его отладку. Поэтому в первую очередь следует учитывать другие решения, такие как списки, упомянутые в ответе Дэвида Разника . При этом я нашел моменты, когда этот класс был полезен для меня и был более удобным в использовании, чем отслеживание индексов элементов, которые нужно удалить.

Изменить: Как упоминалось в комментариев, этот ответ действительно не представляет проблемы, для которой этот подход обеспечивает решение. Я попытаюсь обратиться к этому здесь:

. Пояснения списков предоставляют способ генерации нового списка, но эти подходы имеют тенденцию рассматривать каждый элемент изолированно, а не текущее состояние списка в целом.

ie

newList = [i for i in oldList if testFunc(i)]

Но что, если результат testFunc зависит от элементов, которые были добавлены к newList уже? Или элементы, все еще находящиеся в oldList, которые могут быть добавлены далее? Может все еще быть способ использовать понимание списка, но он начнет терять свою элегантность, и для меня легче изменить список на месте.

Ниже приведен один из примеров алгоритма, который страдает от вышеуказанной проблемы. Алгоритм уменьшит список, так что ни один элемент не будет кратен никакому другому элементу.

randInts = [70, 20, 61, 80, 54, 18, 7, 18, 55, 9]
fRandInts = FluidIterable(randInts)
fRandIntsIter = fRandInts.__iter__()
# for each value in the list (outer loop)
# test against every other value in the list (inner loop)
for i in fRandIntsIter:
    print(' ')
    print('outer val: ', i)
    innerIntsIter = fRandInts.__iter__()
    for j in innerIntsIter:
        innerIndex = innerIntsIter.currentIndex
        # skip the element that the outloop is currently on
        # because we don't want to test a value against itself
        if not innerIndex == fRandIntsIter.currentIndex:
            # if the test element, j, is a multiple 
            # of the reference element, i, then remove 'j'
            if j%i == 0:
                print('remove val: ', j)
                # remove element in place, without breaking the
                # iteration of either loop
                del fRandInts[innerIndex]
            # end if multiple, then remove
        # end if not the same value as outer loop
    # end inner loop
# end outerloop

print('')
print('final list: ', randInts)

Вывод и окончательный сокращенный список показаны ниже

outer val:  70

outer val:  20
remove val:  80

outer val:  61

outer val:  54

outer val:  18
remove val:  54
remove val:  18

outer val:  7
remove val:  70

outer val:  55

outer val:  9
remove val:  18

final list:  [20, 61, 7, 55, 9]