Если вы не знаете, какой длины список заранее, как вы планируете поместить в исходный код достаточное количество переменных для их хранения?
Вообще говоря, если у вас есть список
list1 = ['item1', 'item2', 'item3', 'item4']
и вы хотите что-то сделать с каждым элементом, вы должны сделать:
for elem in list1:
print(elem) # this prints each element on a new line
Вам не нужен индекс вообще (80 +% времени).Если вам также нужен индекс, используйте enumerate():
for index,elem in enumerate(list1):
print(index, elem)
Вывод:
0 item1
1 item2
2 item3
3 item4
Если у вас есть верхняя граница для ваших элементов и "безвредные" значения по умолчаниюВы можете немного обмануть:
a,b,c,d,e,f,g,h,i,k, *_ = list1 + [""]* 11
В этом случае буквы будут заполнены элементами списка list1, а любой элемент «non-present» займет одну из пустых строк.*_ будет использовать оставшуюся часть списка.
Это работает только для небольших диапазонов - например, если вы получаете 3-8 строк и хотите иметь "" для любого, который не предоставлен.Я мог бы использовать это, если мне нужно несколько из этих строк одновременно, а не друг за другом.
Пример:
list1 = ['item1', 'item2', 'item3','item4']
a,b,c,d,e,f,g,h,i,k, *_ = list1 + [""]* 11 # extract into 11 vars
for elem in [a,b,c,d,e,f,g,h,i,k,_]: # stuff all of them back into a list to print
print(elem) # using less code - lists are cool
Вывод:
item1 # a
item2 # b
item3 # c
item4 # d
# e
# f
# g
# h
# i
# k
['', '', '', '', ''] # _
Доку:
Пример использования декомпозиции списка (и более разумный способ сделать это - почти всегда есть лучший способ, чем прибегнуть к "обманчивому" декомпозиции списка со значениями по умолчанию).
Задача: вычислить f(x) = k_0 + k_1*x +k_2*x**2 + ... для до x**5 из введенного пользователем списка, который содержит от 1 до 6 элементов:
def calc_f(my_coeff, x):
# padd list with enough 0 (neutral in our case) to avoid indexerrors
"""Using decomposition"""
padded_list = my_coeff + [0] * 6
# extract into vars
a,b,c,d,e,f,*_ = padded_list
return a + b*x +c*x**2 + d*x**3 + e*x**4 + f*x**5
def calc_f_loop_1(my_coeff,x):
"""Using simple loop and manual sum"""
s = 0
idx = 0
# basic approach without enumerate
for elem in my_coeff:
s += elem*x**idx
idx+=1
return s
def calc_f_loop_2(my_coeff,x):
"""Using better loop, still manual sum"""
s = 0
for idx, elem in enumerate(my_coeff):
s += elem*x**idx
idx+=1
return s
все эти работы ...но это умнее (и более чётко):
calc_f_smarter = lambda l,x: sum( pl*x**idx for idx,pl in enumerate(l) )
Тест:
list1 = [5, 3, 3, 4] # variable input - max. 6 numbers
for method, f in (
("calc_f",calc_f),
("calc_f_loop_1",calc_f_loop_1),
("calc_f_loop_2",calc_f_loop_2),
("calc_f_smarter",calc_f_smarter)):
print(f"{method:<15}:", [f(list1,x) for x in range(-5,5)])
Выходы:
calc_f : [-435, -215, -85, -21, 1, 5, 15, 55, 149, 321]
calc_f_loop_1 : [-435, -215, -85, -21, 1, 5, 15, 55, 149, 321]
calc_f_loop_2 : [-435, -215, -85, -21, 1, 5, 15, 55, 149, 321]
calc_f_smarter : [-435, -215, -85, -21, 1, 5, 15, 55, 149, 321]