Mam listę jak poniżej, gdzie pierwszy element to identyfikator, a drugi jest ciągiem:

[(1, u'abc'), (2, u'def')]

Chcę utworzyć listę identyfikatorów tylko z tej listy Kto | jak poniżej:

[1,2]

Użyję tej listy w __in, więc musi być lista wartości całkowitych.

186
wasimbhalli 27 sierpień 2012, 16:38

10 odpowiedzi

Najlepsza odpowiedź
>>> a = [(1, u'abc'), (2, u'def')]
>>> [i[0] for i in a]
[1, 2]
270
cs95 22 styczeń 2018, 10:09

Myślałem, że może być przydatne porównywanie czasów różnych podejść, więc dokonałem benchmarku (przy użyciu Simple_benchmark biblioteka)

i) benchmark posiadający tule z 2 elementami Wpisz opis obrazu tutaj

Jak można spodziewać się wybrania pierwszego elementu z Ktoples przez indeks {X0}} pokazuje, że jest najszybszym rozwiązaniem bardzo blisko rozpakowywania rozwiązania, spodziewając się dokładnie 2 wartości

import operator
import random

from simple_benchmark import BenchmarkBuilder

b = BenchmarkBuilder()



@b.add_function()
def rakesh_by_index(l):
    return [i[0] for i in l]


@b.add_function()
def wayneSan_zip(l):
    return list(list(zip(*l))[0])


@b.add_function()
def bcattle_itemgetter(l):
     return list(map(operator.itemgetter(0), l))


@b.add_function()
def ssoler_upacking(l):
    return [idx for idx, val in l]

@b.add_function()
def kederrack_unpacking(l):
    return [f for f, *_ in l]



@b.add_arguments('Number of tuples')
def argument_provider():
    for exp in range(2, 21):
        size = 2**exp
        yield size, [(random.choice(range(100)), random.choice(range(100))) for _ in range(size)]


r = b.run()
r.plot()

II) Benchmark posiadający tule z 2 lub więcej elementów Wpisz opis obrazu tutaj

import operator
import random

from simple_benchmark import BenchmarkBuilder

b = BenchmarkBuilder()

@b.add_function()
def kederrack_unpacking(l):
    return [f for f, *_ in l]


@b.add_function()
def rakesh_by_index(l):
    return [i[0] for i in l]


@b.add_function()
def wayneSan_zip(l):
    return list(list(zip(*l))[0])


@b.add_function()
def bcattle_itemgetter(l):
     return list(map(operator.itemgetter(0), l))


@b.add_arguments('Number of tuples')
def argument_provider():
    for exp in range(2, 21):
        size = 2**exp
        yield size, [tuple(random.choice(range(100)) for _
                     in range(random.choice(range(2, 100)))) for _ in range(size)]

from pylab import rcParams
rcParams['figure.figsize'] = 12, 7

r = b.run()
r.plot()
5
kederrac 18 luty 2020, 12:32

Możesz Rozpakuj Kto | i uzyskaj tylko pierwszy element za pomocą rozumienia listy :

l = [(1, u'abc'), (2, u'def')]
[f for f, *_ in l]

wyjście:

[1, 2]

Będzie to działać bez względu na to, ile elementów masz w krotce:

l = [(1, u'abc'), (2, u'def', 2, 4, 5, 6, 7)]
[f for f, *_ in l]

wyjście:

[1, 2]
0
kederrac 17 luty 2020, 19:03

Użyj funkcji ZIP, aby odłączyć elementy:

>>> inpt = [(1, u'abc'), (2, u'def')]
>>> unzipped = zip(*inpt)
>>> print unzipped
[(1, 2), (u'abc', u'def')]
>>> print list(unzipped[0])
[1, 2]

edytuj (@bradsolomon): Powyższe prace dla Pythona 2.x, gdzie zip zwraca listę.

W Pythonie 3.x, {X0}} zwraca iteratora, a poniższe są równoważne powyżej:

>>> print(list(list(zip(*inpt))[0]))
[1, 2]
73
Community 12 grudzień 2018, 18:41

Możesz użyć "Tuple rozpakowanie":

>>> my_list = [(1, u'abc'), (2, u'def')]
>>> my_ids = [idx for idx, val in my_list]
>>> my_ids
[1, 2]

W czasie iteracji każda krotka jest rozpakowywana, a jego wartości są ustawione na zmienne idx i val.

>>> x = (1, u'abc')
>>> idx, val = x
>>> idx
1
>>> val
u'abc'
12
ssoler 16 październik 2020, 08:46

To jest to, co {x0}} jest dla.

>>> a = [(1, u'abc'), (2, u'def')]
>>> import operator
>>> b = map(operator.itemgetter(0), a)
>>> b
[1, 2]

Oświadczenie itemgetter Zwraca funkcję , która zwraca indeks określonego elementu. Jest dokładnie taki sam jak pisanie

>>> b = map(lambda x: x[0], a)

Ale stwierdzam, że itemgetter jest wyraźniejszy i Więcej wyraźnie .

To jest przydatne do wykonywania kompaktowych oświadczeń sortowania. Na przykład,

>>> c = sorted(a, key=operator.itemgetter(0), reverse=True)
>>> c
[(2, u'def'), (1, u'abc')]
10
bcattle 28 czerwiec 2016, 04:43

Jeśli Ktoki są wyjątkowe, może to działać

>>> a = [(1, u'abc'), (2, u'def')]
>>> a
[(1, u'abc'), (2, u'def')]
>>> dict(a).keys()
[1, 2]
>>> dict(a).values()
[u'abc', u'def']
>>> 
7
Jiri Semmler 29 wrzesień 2015, 14:36

Z punktu widzenia wydajności w Python3.x

  • [i[0] for i in a] i {x1}} są równoważne
  • Są szybsze niż list(map(operator.itemgetter(0), a))

Kod

import timeit


iterations = 100000
init_time = timeit.timeit('''a = [(i, u'abc') for i in range(1000)]''', number=iterations)/iterations
print(timeit.timeit('''a = [(i, u'abc') for i in range(1000)]\nb = [i[0] for i in a]''', number=iterations)/iterations - init_time)
print(timeit.timeit('''a = [(i, u'abc') for i in range(1000)]\nb = list(zip(*a))[0]''', number=iterations)/iterations - init_time)

wyjście

3.491014136001468E-05.

3.422205176000717e-05.

7
mxdbld 30 grudzień 2017, 23:54

Kiedy biegałem (jak sugerowano powyżej):

>>> a = [(1, u'abc'), (2, u'def')]
>>> import operator
>>> b = map(operator.itemgetter(0), a)
>>> b

Zamiast powracać:

[1, 2]

Otrzymałem to jako zwrot:

<map at 0xb387eb8>

Znalazłem, że muszę użyć listy ():

>>> b = list(map(operator.itemgetter(0), a))

Aby pomyślnie zwrócić listę za pomocą tej sugestii. To powiedział, jestem zadowolony z tego rozwiązania dzięki. (Testowany / Uruchom za pomocą Spyder, IPython Console, Python V3.6)

4
James 20 marzec 2017, 05:46

To są skórki, nie są ustawiane. Możesz to zrobić:

l1 = [(1, u'abc'), (2, u'def')]
l2 = [(tup[0],) for tup in l1]
l2
>>> [(1,), (2,)]
0
Lanaru 27 sierpień 2012, 12:40