파이썬의 우편 목록

목록을 압축하는 방법을 배우려고합니다. 이를 위해 특정 시점에서 다음을 수행하는 프로그램이 있습니다.

x1, x2, x3 = stuff.calculations(withdataa)

이것은 나에게 세 가지 목록을 제공 x1, x2그리고 x3, 각각의 말, 크기 20.

이제는 :

zipall = zip(x1, x2, x3)

그러나 내가 할 때 :

print "len of zipall %s" % len(zipall)

나는 20을 얻습니다. 나는 세 가지를 기대했다. 나는 근본적으로 잘못된 일을하고 있다고 생각합니다.

zip()각각 20 개의 요소를 포함하는 세 개의 목록 을 함께 사용하면 결과에 20 개의 요소가 있습니다. 각 요소는 3 개의 튜플입니다.

직접 참조하십시오 :

In [1]: a = b = c = range(20)

In [2]: zip(a, b, c)
Out[2]: 
[(0, 0, 0),
 (1, 1, 1),
 ...
 (17, 17, 17),
 (18, 18, 18),
 (19, 19, 19)]

각 튜플에 포함 된 요소 수를 확인하려면 첫 번째 요소의 길이를 검사하십시오.

In [3]: result = zip(a, b, c)

In [4]: len(result[0])
Out[4]: 3

물론 목록이 비어 있으면 작동하지 않습니다.

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)합니다. 왼쪽에서 오른쪽으로 지퍼를 수평으로 그리는다고 상상해보십시오.

파이썬 2.7에서 이것은 잘 작동했을 것입니다 :

>>> a = b = c = range(20)
>>> zip(a, b, c)

그러나 파이썬 3.4에서는 (그렇지 않으면 결과는 다음과 같습니다 <zip object at 0x00000256124E7DC8>) :

>>> a = b = c = range(20)
>>> list(zip(a, b, c))

zip 반복 가능한 인수의 요소를 포함하는 튜플로 채워진 새 목록을 만듭니다.

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

각 요소가 목록 인 튜플을 만드는 것이 좋습니다.

출처 : 내 블로그 게시물 (더 나은 형식)

예

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

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

입력

0 개 이상의 이터 러블 [1] (예 : 목록, 문자열, 튜플, 사전)

출력 (목록)

첫 번째 튜플 = (숫자 element_1, 문자 element_1)

두 번째 튜플 = (e_2 숫자, e_2 문자)

…

n 번째 튜플 = (e_n 숫자, e_n 문자)

1. n 튜플 목록 : n은 가장 짧은 인수의 길이입니다 (입력).
   • len (numbers) == 3 <len (letters) == 4 → short = 3 → 3 튜플 반환
2. 각 튜플의 길이 = 인수 수 (튜플은 각 인수에서 요소를 가져옵니다)
   • 인수 = (숫자, 문자); len (args) == 2 → 2 개의 요소가있는 튜플
3. ith 튜플 = (element_i arg1, element_i arg2…, element_i arg n)

가장자리 케이스

1) 빈 문자열 : len (str) = 0 = 튜플 없음

2) 단일 문자열 : len (str) == len (args) == 1 개의 요소가있는 2 개의 튜플

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

행동의 지퍼!

1. 두리스트 중 사전을 구축한다 [2]

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]

• zip 우아하고 명확하며 간결한 솔루션입니다

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')

추가 크레딧 : 압축 해제

zip(*args) "unzipping"이라고 불리며 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')]

• unzipped: tuple_1 = 압축 된 각 튜플의 e1 tuple_2 = 각각의 e2zipped

각주

1. 한 번에 하나씩 구성원을 리턴 할 수있는 오브젝트 (예 : 목록 [1,2,3], 문자열 'I like codin', 튜플 (1,2,3), 사전 { 'a': 1, 'b' : 2})
2. {key1 : value1, key2 : value2 ...}
3. “포장 풀기”(*)

* 암호:

# 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 개 인수) 가져 와서 2 개의 요소를 2 개 인수로 '포장 풀기'

기본적으로 zip 함수는 Python의 목록, 튜플 및 사전에서 작동합니다. IPython을 사용하는 경우 zip을 입력하십시오. 그리고 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')]

파이썬 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압축 된 반복기를 다시 결합하십시오.

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']

완전성을 위해.

압축 된 목록의 길이가 동일하지 않은 경우 결과 목록의 길이는 오류없이 가장 짧은 길이가됩니다

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

나는 zip목록을 반환 하지 않는다고 생각 합니다. zip발전기를 반환합니다. list(zip(a, b))튜플 목록을 얻으려면 해야 합니다.

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

zip에 대한 높은 순위의 질문이므로 여기에 추가 할 가치가 있습니다. zip대단한 관용적 인 파이썬이지만 큰 목록에는 전혀 확장 성이 없습니다.

대신에:

books = ['AAAAAAA', 'BAAAAAAA', ... , 'ZZZZZZZ']
words = [345, 567, ... , 672]

for book, word in zip(books, words):
   print('{}: {}'.format(book, word))

사용하십시오 izip. 최신 처리를 위해 L1 캐시 메모리에 저장하며 더 큰 목록의 경우 훨씬 성능이 우수합니다. 단순히 다음을 추가하는 것처럼 사용하십시오 i.

for book, word in izip(books, words):
   print('{}: {}'.format(book, word))