置き換/解凍機能（逆のzip)?

StackOverflow https://stackoverflow.com/questions/19339

  •  09-06-2019
  •  | 
  •  

質問

いリストの2項目によるタプルと思う"という2つのリストの最初の最初の項目は各タプルのリストを保持する第二の商品です。

例えば:

original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
# and I want to become...
result = (['a', 'b', 'c', 'd'], [1, 2, 3, 4])

ある組み込み機能する。

役に立ちましたか？

解決

zip 独自の逆!の提供をご利用の特別*オペレーター

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

にこの作品を呼び出し zip の引数:

zip(('a', 1), ('b', 2), ('c', 3), ('d', 4))

...以外の引数に渡される zip を直接に変換して転要素からなるタプルでありない数の引数に乗っています。

他のヒント

このままい

result = ([ a for a,b in original ], [ b for a,b in original ])

で すべ 規模ります。その場合のPythonげようとするが、な拡大、リストの理解います。

(ちなみに、この2タプル(ペア)のリストによるのではなく、リストタプルのように、 zip ます。)

場合に発電機の代わりに実際のリストは、このような:

result = (( a for a,b in original ), ( b for a,b in original ))

発電機なミュニティの一覧までお願いを各要素が一方で、いいオリジナルを参照します。

場合のリストは同じ長させるために使用zipてPatricksの答えです。この作品:

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)])
[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]

が異なる長さのリストを、zip truncates各項目の長さは最短のリスト:

>>> zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e')]

利用できる地図のない機能を埋め空結果とな

>>> map(None, *[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', )])
[('a', 'b', 'c', 'd', 'e'), (1, 2, 3, 4, None)]

zip()は小幅に速くなってる。

私のように利用 zip(*iterable) （作品のコードを探そういうプログラムとしてい:

def unzip(iterable):
    return zip(*iterable)

見 unzip 易い。

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> tuple([list(tup) for tup in zip(*original)])
(['a', 'b', 'c', 'd'], [1, 2, 3, 4])

このタプルのリストとしての問題をもたらしていました。

list1, list2 = [list(tup) for tup in zip(*original)]

開梱の一覧表も掲載しています。

この他について教えてくださいがいっぱいので、ここに書くのはやめておき:

このデータ構造:

X=[1,2,3,4]
Y=['a','b','c','d']
XY=zip(X,Y)

より:

In: XY
Out: [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]

のpythonicに解凍しまに戻ると、以下のようになっていれているものについてはこの私の意見:

x,y=zip(*XY)

このタプルを返しますので必要な場合は、リストを使用でき

x,y=(list(x),list(y))

ナイーブアプローチ

def transpose_finite_iterable(iterable):
    return zip(*iterable)  # `itertools.izip` for Python 2 users

色が有限のlistなど配列のように list/tuple/str の(潜在的に無限大)iterablesできる絵のように

| |a_00| |a_10| ... |a_n0| |
| |a_01| |a_11| ... |a_n1| |
| |... | |... | ... |... | |
| |a_0i| |a_1i| ... |a_ni| |
| |... | |... | ... |... | |

場所

  • n in ℕ,
  • a_ij に対応する j-th要素の i番目のlist,

および適用後の transpose_finite_iterable ま

| |a_00| |a_01| ... |a_0i| ... |
| |a_10| |a_11| ... |a_1i| ... |
| |... | |... | ... |... | ... |
| |a_n0| |a_n1| ... |a_ni| ... |

Pythonでは、このような場合 a_ij == j, n == 2

>>> from itertools import count
>>> iterable = [count(), count()]
>>> result = transpose_finite_iterable(iterable)
>>> next(result)
(0, 0)
>>> next(result)
(1, 1)

そして何よりも重要なのは使用 transpose_finite_iterable 再帰構造の原 iterable ので result は無限のlistの有限iterables(tuples"この例の場合):

>>> transpose_finite_iterable(result)
... hangs ...
Traceback (most recent call last):
  File "...", line 1, in ...
  File "...", line 2, in transpose_finite_iterable
MemoryError

定できるようになりましたができます。

...は-- deque

しくはdocsの itertools.tee 機能, あPythonのレシピが一部変更できる場合には

def transpose_finite_iterables(iterable):
    iterator = iter(iterable)
    try:
        first_elements = next(iterator)
    except StopIteration:
        return ()
    queues = [deque([element])
              for element in first_elements]

    def coordinate(queue):
        while True:
            if not queue:
                try:
                    elements = next(iterator)
                except StopIteration:
                    return
                for sub_queue, element in zip(queues, elements):
                    sub_queue.append(element)
            yield queue.popleft()

    return tuple(map(coordinate, queues))

リボルテッククイーンズブレイド

>>> from itertools import count
>>> iterable = [count(), count()]
>>> result = transpose_finite_iterables(transpose_finite_iterable(iterable))
>>> result
(<generator object transpose_finite_iterables.<locals>.coordinate at ...>, <generator object transpose_finite_iterables.<locals>.coordinate at ...>)
>>> next(result[0])
0
>>> next(result[0])
1

合成

できていなかったのを定義する機能とiterablesのiterablesものである限り、別のものは無限の可能性を functools.singledispatch デコレータ のように

from collections import (abc,
                         deque)
from functools import singledispatch


@singledispatch
def transpose(object_):
    """
    Transposes given object.
    """
    raise TypeError('Unsupported object type: {type}.'
                    .format(type=type))


@transpose.register(abc.Iterable)
def transpose_finite_iterables(object_):
    """
    Transposes given iterable of finite iterables.
    """
    iterator = iter(object_)
    try:
        first_elements = next(iterator)
    except StopIteration:
        return ()
    queues = [deque([element])
              for element in first_elements]

    def coordinate(queue):
        while True:
            if not queue:
                try:
                    elements = next(iterator)
                except StopIteration:
                    return
                for sub_queue, element in zip(queues, elements):
                    sub_queue.append(element)
            yield queue.popleft()

    return tuple(map(coordinate, queues))


def transpose_finite_iterable(object_):
    """
    Transposes given finite iterable of iterables.
    """
    yield from zip(*object_)

try:
    transpose.register(abc.Collection, transpose_finite_iterable)
except AttributeError:
    # Python3.5-
    transpose.register(abc.Mapping, transpose_finite_iterable)
    transpose.register(abc.Sequence, transpose_finite_iterable)
    transpose.register(abc.Set, transpose_finite_iterable)

できると考え、独自の逆数(数学者がこういう機能 "involutions")クラスのバイナリー事業者間の数空iterables.

ボーナスパーツとしての singledispatchングまで対応可能 numpy 配列のように

import numpy as np
...
transpose.register(np.ndarray, np.transpose)

そのような気分で使ってくだ

>>> array = np.arange(4).reshape((2,2))
>>> array
array([[0, 1],
       [2, 3]])
>>> transpose(array)
array([[0, 2],
       [1, 3]])

注意

以降 transpose 反復子を返しますやばいい tuple の lists様OP--動作させることができるまたと map 内蔵機能 のように

>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> tuple(map(list, transpose(original)))
(['a', 'b', 'c', 'd'], [1, 2, 3, 4])

広告

私は追加の一般化を解 lz パッケージ から 0.5.0 版を使用できるように

>>> from lz.transposition import transpose
>>> list(map(tuple, transpose(zip(range(10), range(10, 20)))))
[(0, 1, 2, 3, 4, 5, 6, 7, 8, 9), (10, 11, 12, 13, 14, 15, 16, 17, 18, 19)]

P.S.

なソリューション(少なくとも明らかな取り扱いにつ潜在的に無限のlistの可能性は無限iterablesが、この場合には共通のものです。

以来、タプルを返します(使用できるトンメモリ)、 zip(*zipped) トリックされてきていることからなり便利です。

この機能が実際には逆のzip.

def unzip(zipped):
    """Inverse of built-in zip function.
    Args:
        zipped: a list of tuples

    Returns:
        a tuple of lists

    Example:
        a = [1, 2, 3]
        b = [4, 5, 6]
        zipped = list(zip(a, b))

        assert zipped == [(1, 4), (2, 5), (3, 6)]

        unzipped = unzip(zipped)

        assert unzipped == ([1, 2, 3], [4, 5, 6])

    """

    unzipped = ()
    if len(zipped) == 0:
        return unzipped

    dim = len(zipped[0])

    for i in range(dim):
        unzipped = unzipped + ([tup[i] for tup in zipped], )

    return unzipped

original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

#unzip 
a1 , a2 = zip(*original)
#make tuple with two list
result=(list(a1),list(a2))
result

result=(['a','b','c','d'], [1, 2, 3, 4])

利用をお考えの more_itertools.解凍し:

>>> from more_itertools import unzip
>>> original = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> [list(x) for x in unzip(original)]
[['a', 'b', 'c', 'd'], [1, 2, 3, 4]]

なし前回答 効率的に 必要な出力は、 タプルのリスト, よるのではなく、 リストのタプル.前者に利用できる tuple と map.この違い:

res1 = list(zip(*original))              # [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
res2 = tuple(map(list, zip(*original)))  # (['a', 'b', 'c', 'd'], [1, 2, 3, 4])

世界的にもほとんどの前提とPython2.7、 zip リストを返すというより、iterator.

Python3.x、合格する必要があり、その結果、機能など list または tuple 排気、iterator.メモリ効率の高い反復子を省略することができ、外 list や tuple 話し、それぞれのソリューション。

ながら zip(*seq) もしも適さない非常に長い配列を生成しますタプルを必要とする価値の渡されます。例えば、できないかなぁ、とおもって、座標システム上の応募いることは言うまでもありませsignifcantly速の配列。

汎用的なアプローチをとるというようになります:

from collections import deque
seq = ((a1, b1, …), (a2, b2, …), …)
width = len(seq[0])
output = [deque(len(seq))] * width # preallocate memory
for element in seq:
    for s, item in zip(output, element):
        s.append(item)

ものによっては、やりたいとの結果では、収集できる大きな差があります。私の実際の使用の場合、セットの内部ループは、あくその他全てのアプローチ。

や、その他を行っている場合には、このデータセット、という意味で使用ても済むサーパンダ館です。

こうしてできる改変、2×4タプルへの4x2タプル. 

 >>> tuple(zip(*[('a', 1), ('b', 2), ('c', 3), ('d', 4)]))

結果

[('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top