Cara menggunakan NP.UNIQUE pada Python

Saya ingin mendapatkan nilai unik dari daftar berikut:

[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']

Output yang saya butuhkan adalah:

[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']

Kode ini berfungsi:

output = []
for x in trends:
    if x not in output:
        output.append[x]
print output

apakah ada solusi yang lebih baik yang harus saya gunakan?

Pertama mendeklarasikan daftar Anda dengan benar, dipisahkan dengan koma. Anda bisa mendapatkan nilai unik dengan mengonversi daftar ke set.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
myset = set[mylist]
print[myset]

Jika Anda menggunakannya lebih lanjut sebagai daftar, Anda harus mengubahnya kembali ke daftar dengan melakukan:

mynewlist = list[myset]

Kemungkinan lain, mungkin lebih cepat adalah menggunakan set dari awal, bukan daftar. Maka kode Anda harus:

output = set[]
for x in trends:
    output.add[x]
print[output]

Seperti yang telah ditunjukkan, set tidak mempertahankan urutan aslinya. Jika perlu, Anda harus mencari tentang set yang diatur .

Agar konsisten dengan tipe yang akan saya gunakan:

mylist = list[set[mylist]]

jenis apa variabel output Anda?

Python set adalah apa yang Anda butuhkan. Nyatakan output seperti ini:

output = set[[]] # initialize an empty set

dan Anda siap untuk menambahkan elemen dengan output.add[elem] dan pastikan itu unik.

Peringatan: set JANGAN mempertahankan urutan asli daftar.

Contoh yang Anda berikan tidak sesuai dengan daftar di Python. Itu menyerupai dict bersarang, yang mungkin bukan apa yang Anda maksudkan.

Daftar Python:

a = ['a', 'b', 'c', 'd', 'b']

Untuk mendapatkan item unik, cukup ubah menjadi set [yang dapat Anda ubah kembali menjadi daftar jika diperlukan]:

b = set[a]
print b
>>> set[['a', 'b', 'c', 'd']]

Jika kita perlu menjaga agar elemen tetap teratur, bagaimana dengan ini:

used = set[]
mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for x in mylist if x not in used and [used.add[x] or True]]

Dan satu lagi solusi menggunakan reduce dan tanpa used var sementara.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce[lambda l, x: l.append[x] or l if x not in l else l, mylist, []]

PEMBARUAN - Maret, 2019

Dan solusi ke-3, yang merupakan solusi yang rapi, tetapi agak lambat karena .index adalah O [n].

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = [x for i, x in enumerate[mylist] if i == mylist.index[x]]

UPDATE - Okt, 2016

Solusi lain dengan reduce, tetapi kali ini tanpa .append yang membuatnya lebih mudah dibaca manusia dan lebih mudah dipahami.

mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
unique = reduce[lambda l, x: l+[x] if x not in l else l, mylist, []]
#which can also be writed as:
unique = reduce[lambda l, x: l if x in l else l+[x], mylist, []]

CATATAN: Perlu diketahui bahwa semakin banyak yang bisa dibaca manusia, skripnya lebih buruk.

import timeit

setup = "mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']"

#10x to Michael for pointing out that we can get faster with set[]
timeit.timeit['[x for x in mylist if x not in used and [used.add[x] or True]]', setup='used = set[];'+setup]
0.4188511371612549

timeit.timeit['[x for x in mylist if x not in used and [used.append[x] or True]]', setup='used = [];'+setup]
0.6157128810882568

timeit.timeit['reduce[lambda l, x: l.append[x] or l if x not in l else l, mylist, []]', setup=setup]
1.8778090476989746

timeit.timeit['reduce[lambda l, x: l+[x] if x not in l else l, mylist, []]', setup=setup]
2.13108491897583

timeit.timeit['reduce[lambda l, x: l if x in l else l+[x], mylist, []]', setup=setup]
2.207760810852051

timeit.timeit['[x for i, x in enumerate[mylist] if i == mylist.index[x]]', setup=setup]
2.3621110916137695

KOMENTAR JAWABAN

Karena @monica menanyakan pertanyaan yang bagus tentang "bagaimana cara kerjanya?". Untuk semua orang yang memiliki masalah mencari tahu. Saya akan mencoba memberikan penjelasan yang lebih mendalam tentang bagaimana ini bekerja dan sihir apa yang terjadi di sini;]

Jadi dia pertama kali bertanya:

Saya mencoba memahami mengapa unique = [used.append[x] for x in mylist if x not in used] tidak berfungsi.

Sebenarnya ini berfungsi

>>> used = []
>>> mylist = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> unique = [used.append[x] for x in mylist if x not in used]
>>> print used
[u'nowplaying', u'PBS', u'job', u'debate', u'thenandnow']
>>> print unique
[None, None, None, None, None]

Masalahnya adalah kita tidak mendapatkan hasil yang diinginkan di dalam variabel unique, tetapi hanya di dalam variabel used. Ini karena selama pemahaman daftar .append memodifikasi variabel used dan mengembalikan None.

Jadi untuk mendapatkan hasil ke variabel unique, dan masih menggunakan logika yang sama dengan .append[x] if x not in used, kita perlu memindahkan panggilan .append ini di sisi kanan daftar pemahaman dan hanya mengembalikan x di sisi kiri.

Tetapi jika kita terlalu naif dan hanya pergi dengan:

>>> unique = [x for x in mylist if x not in used and used.append[x]]
>>> print unique
[]

Kami tidak akan mendapatkan imbalan apa pun.

Sekali lagi, ini karena metode .append mengembalikan None, dan ini memberikan pada ekspresi logis kita tampilan berikut:

x not in used and None

Ini pada dasarnya akan selalu:

1. mengevaluasi ke False ketika x berada di used,
2. mengevaluasi ke None ketika x tidak dalam used.

Dan dalam kedua kasus [False/None], ini akan diperlakukan sebagai nilai falsy dan kami akan mendapatkan daftar kosong sebagai hasilnya.

Tetapi mengapa ini mengevaluasi ke None ketika x tidak dalam used? Seseorang mungkin bertanya.

Yah itu karena ini adalah cara Python hubungan pendek operator bekerja .

Ekspresi x and y pertama mengevaluasi x; jika x salah, nilainya dikembalikan; jika tidak, y dievaluasi dan nilai yang dihasilkan dikembalikan.

Jadi ketika x tidak digunakan [yaitu ketika True]} _ bagian selanjutnya atau ekspresi akan dievaluasi [used.append[x]] dan nilainya [None] akan dikembalikan.

Tapi itulah yang kami inginkan untuk mendapatkan elemen unik dari daftar dengan duplikat, kami ingin .append mereka menjadi daftar baru hanya ketika kami menemukan waktu pertama.

Jadi kita benar-benar ingin mengevaluasi used.append[x] hanya ketika x tidak dalam used, mungkin jika ada cara untuk mengubah nilai None ini menjadi truthy yang kita akan baik-baik saja, kan?

Ya, ya dan di sinilah jenis kedua operator short-circuit datang untuk bermain.

Ekspresi x or y pertama mengevaluasi x; jika x benar, nilainya dikembalikan; jika tidak, y dievaluasi dan nilai yang dihasilkan dikembalikan.

Kita tahu bahwa .append[x] akan selalu menjadi falsy, jadi jika kita hanya menambahkan satu or di sebelahnya, kita akan selalu mendapatkan bagian selanjutnya. Itu sebabnya kami menulis:

x not in used and [used.append[x] or True]

jadi kita dapat mengevaluasi used.append[x] dan mendapatkan True sebagai hasilnya, hanya ketika bagian pertama dari ekspresi [x not in used] adalah True.

Cara serupa dapat dilihat pada pendekatan ke-2 dengan metode reduce.

[l.append[x] or l] if x not in l else l
#similar as the above, but maybe more readable
#we return l unchanged when x is in l
#we append x to l and return l when x is not in l
l if x in l else [l.append[x] or l]

dimana kita:

1. Tambahkan x ke l dan kembalikan l saat x tidak ada dalam l. Berkat pernyataan or.append dievaluasi dan l dikembalikan setelah itu.
2. Kembalikan l tidak tersentuh ketika x ada di l

Mempertahankan pesanan:

# oneliners
# slow -> . --- 14.417 seconds ---
[x for i, x in enumerate[array] if x not in array[0:i]]

# fast -> . --- 0.0378 seconds ---
[x for i, x in enumerate[array] if array.index[x] == i]

# multiple lines
# fastest -> --- 0.012 seconds ---
uniq = []
[uniq.append[x] for x in array if x not in uniq]
uniq

Urutan tidak masalah:

# fastest-est -> --- 0.0035 seconds ---
list[set[array]]

Ini adalah solusi sederhana-

list=[u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
list=set[list]

Mendapatkan elemen unik dari Daftar

mylist = [1,2,3,4,5,6,6,7,7,8,8,9,9,10]

Menggunakan Logika Sederhana dari Perangkat - Perangkat adalah daftar item yang unik

mylist=list[set[mylist]]

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Menggunakan Logika Sederhana

newList=[]
for i in mylist:
    if i not in newList:
        newList.append[i]

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Menggunakan metode pop -> pop menghapus item terakhir atau yang diindeks dan menampilkannya kepada pengguna. video

k=0
while k < len[mylist]:
    if mylist[k] in mylist[k+1:]:
        mylist.pop[mylist[k]]
    else:
        k=k+1

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Menggunakan Numpy

import numpy as np
np.unique[mylist]

In [0]: mylist
Out[0]: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Referensi

set - koleksi elemen unik tanpa urutan. Daftar elemen dapat diteruskan ke konstruktor set. Jadi, lewati daftar dengan elemen duplikat, kita ditetapkan dengan elemen unik dan mengubahnya kembali ke daftar lalu dapatkan daftar dengan elemen unik. Saya tidak bisa mengatakan apa-apa tentang kinerja dan memori overhead, tapi saya harap, itu tidak begitu penting dengan daftar kecil.

list[set[my_not_unique_list]]

Sederhana dan singkat.

Jika Anda menggunakan numpy dalam kode Anda [yang mungkin merupakan pilihan yang baik untuk jumlah data yang lebih besar], periksa numpy.unique :

>>> import numpy as np
>>> wordsList = [u'nowplaying', u'PBS', u'PBS', u'nowplaying', u'job', u'debate', u'thenandnow']
>>> np.unique[wordsList]
array[[u'PBS', u'debate', u'job', u'nowplaying', u'thenandnow'], 
      dtype='