Лучший способ объединить два списка значений integer и float с помощью Python [duplicate]

В Python 3 zip вместо этого возвращает итератор и должен быть передан в функцию списка, чтобы получить заархивированные кортежи:

x = [1, 2, 3]; y = ['a','b','c']
z = zip(x, y)
z = list(z)
print(z)
>>> [(1, 'a'), (2, 'b'), (3, 'c')]

Затем, чтобы unzip их обратно просто сопрягали zipped iterator :

x_back, y_back = zip(*z)
print(x_back); print(y_back)
>>> (1, 2, 3)
>>> ('a', 'b', 'c')

Если исходная форма списка необходима вместо кортежей:

x_back, y_back = zip(*z)
print(list(x_back)); print(list(y_back))
>>> [1,2,3]
>>> ['a','b','c']

Источник: «Моя запись в блоге» (лучшее форматирование)

Пример

numbers = [1,2,3]
letters = 'abcd'

zip(numbers, letters)
# [(1, 'a'), (2, 'b'), (3, 'c')]

Вход

Ноль или более итераций [1] (например, string, tuple, dictionary)

Вход (список)

Крайние случаи

1) Пустая строка: len (str) = 0 = нет кортежей

2) Single String: len (str) == 2 кортежа с len (args) == 1 элемент (ы)

zip()
# []
zip('')
# []
zip('hi')
# [('h',), ('i',)]

Edge Cases

Пример

keys = ["drink","band","food"]
values = ["La Croix", "Daft Punk", "Sushi"]

my_favorite = dict( zip(keys, values) )

my_favorite["drink"]
# 'La Croix'

my_faves = dict()
for i in range(len(keys)):
    my_faves[keys[i]] = values[i]

2. Печать столбцов в таблице

«*» [3] называется «распаковкой»: f(*[arg1,arg2,arg3]) == f(arg1, arg2, arg3)

student_grades = [
[   'Morty'  ,  1   ,  "B"  ],
[   'Rick'   ,  4   ,  "A"  ],
[   'Jerry'  ,  3   ,  "M"  ],
[  'Kramer'  ,  0   ,  "F"  ],
]

row_1 = student_grades[0]
print row_1
# ['Morty', 1, 'B']

columns = zip(*student_grades)
names = columns[0]
print names
# ('Morty', 'Rick', 'Jerry', 'Kramer')

Extra Credit: Распаковка

zip(*args) называется «распаковкой», потому что он имеет обратный эффект zip

numbers = (1,2,3)
letters = ('a','b','c')

zipped = zip(numbers, letters)
print zipped
# [(1, 'a'), (2, 'b'), (3, 'c')]

unzipped = zip(*zipped)
print unzipped
# [(1, 2, 3), ('a', 'b', 'c')]

Сноски

* Код:

# foo - function, returns sum of two arguments
def foo(x,y):
    return x + y
print foo(3,4)
# 7

numbers = [1,2]
print foo(numbers)
# TypeError: foo() takes exactly 2 arguments (1 given)

print foo(*numbers)
# 3

* взял numbers (1 arg) и «Распаковал» его «2 элемента в 2 аргумента

zip берет кучу списков, похожих на

a: a1 a2 a3 a4 a5 a6 a7...
b: b1 b2 b3 b4 b5 b6 b7...
c: c1 c2 c3 c4 c5 c6 c7...

и «застегивает» их в один список, чьи записи являются 3-мя корнями (ai, bi, ci). Представьте, что вы рисуете молнию горизонтально слева направо.

Я не думаю, что zip возвращает список. zip возвращает генератор. Вы должны сделать list(zip(a, b)), чтобы получить список кортежей.

x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
list(zipped)

zip создает новый список, заполненный кортежами, содержащими элементы из итерируемых аргументов:

>>> zip ([1,2],[3,4])
[(1,3), (2,4)]

Я ожидаю, что вы попытаетесь создать такой кортеж, где каждый элемент является списком. [ ! d1]

Для полноты.

Когда длины заархивированных списков не равны. Длина списка результатов станет самой короткой без ошибок.

>>> a = [1]
>>> b = ["2", 3]
>>> zip(a,b)
[(1, '2')]

В основном функция zip работает с списками, кортежами и словарями на Python. Если вы используете IPython, тогда просто введите zip?

Если вы не используете IPython, просто установите его: «pip install ipython»

Для списков

a = ['a', 'b', 'c']
b = ['p', 'q', 'r']
zip(a, b)

Выход [('a', 'p'), ('b', 'q'), ('c', 'r')

Для словаря:

c = {'gaurav':'waghs', 'nilesh':'kashid', 'ramesh':'sawant', 'anu':'raje'}
d = {'amit':'wagh', 'swapnil':'dalavi', 'anish':'mane', 'raghu':'rokda'}
zip(c, d)

Выход:

[('gaurav', 'amit'),
 ('nilesh', 'swapnil'),
 ('ramesh', 'anish'),
 ('anu', 'raghu')]