Persimpangan python dari dua daftar

Posting ini menjelaskan kode untuk setiap metode dan membahas berbagai faktor yang perlu dipertimbangkan saat memutuskan metode mana yang akan digunakan

Table of Contents Show

Menggunakan set untuk menemukan persimpangan dua daftar dengan Python
Perbedaan utama antara satu set dan daftar
Mengubah daftar menjadi set dan menggunakan operator &
Mengubah daftar menjadi set dan menggunakan metode interseksi()
Terjadi kesalahan saat mengonversi daftar menjadi kumpulan
Menggunakan pemahaman daftar
Menggunakan pemahaman daftar untuk membuat daftar persimpangan baru
Menggunakan pemahaman daftar untuk menemukan persimpangan dua daftar dengan daftar bersarang
Menggunakan fungsi filter() bawaan
Menggunakan fungsi filter() untuk menemukan persimpangan dua daftar dengan Python
Menggunakan fungsi filter() dengan fungsi lambda
Metode Mana yang Digunakan?
Latihan Soal
Hasil yang diharapkan
Solusi yang Disarankan
Bagaimana Anda memotong dua daftar dengan Python?
Bagaimana menemukan persimpangan dua daftar string dengan Python?
Bagaimana menemukan persimpangan lebih dari dua daftar dengan Python?
Apa 3 cara berbeda untuk menggabungkan 2 daftar dengan Python?

Untuk soal latihan, kita akan mengerjakan fungsi yang menemukan perpotongan dua daftar dengan item duplikat di setiap daftar. Misalnya, jika kita meneruskan daftar

[3, 4, 5]

8 dan

[3, 4, 5]

9 ke fungsi, itu harus mengembalikan daftar

<name of set>.intersection(<names of interables>)

Daftar isi

Menggunakan set untuk menemukan persimpangan dua daftar dengan Python

Metode pertama untuk menemukan persimpangan dua daftar dengan Python adalah mengonversi daftar menjadi set dan menggunakan operator

<name of set>.intersection(<names of interables>)

1 atau metode

<name of set>.intersection(<names of interables>)

2 bawaan

Tapi pertama-tama, apa itu himpunan?

Set mirip dengan daftar, karena dapat digunakan untuk menyimpan kumpulan item (seperti kumpulan angka)

Misalnya, kita dapat membuat satu set untuk menyimpan angka 1, 22, 43, 64 dan 57

Untuk melakukan itu, kami menggunakan kurung kurawal, seperti yang ditunjukkan pada contoh di bawah ini

mySet = {1, 22, 43, 64, 57}

Seperti yang Anda lihat, membuat satu set sangat mirip dengan membuat daftar, kecuali yang pertama menggunakan kurung kurawal sedangkan yang kedua menggunakan tanda kurung siku.

Satu set memang sangat mirip dengan daftar. Namun, ada beberapa perbedaan utama di antara keduanya, seperti yang dijelaskan pada tabel di bawah ini

Perbedaan utama antara satu set dan daftar

ListSetItems dipesan (mis. e. urutan item penting)

Oleh karena itu,

<name of set>.intersection(<names of interables>)

_3 dan

<name of set>.intersection(<names of interables>)

4 dianggap sebagai dua daftar yang berbeda

Item tidak dipesan (mis. e. urutan item diabaikan)

Oleh karena itu,

<name of set>.intersection(<names of interables>)

_5 dan

<name of set>.intersection(<names of interables>)

6 dianggap sebagai himpunan yang sama

Item tidak harus berbeda

<name of set>.intersection(<names of interables>)

7 baik-baik saja

Item harus berbeda

<name of set>.intersection(<names of interables>)

8 memberi kita kesalahan karena angka 1 muncul lebih dari sekali di set

Item tidak perlu hashable*Item harus hashable*

Contoh item yang hashable termasuk bilangan bulat, bilangan titik-mengambang, dan string

Contoh item yang tidak dapat di-hash termasuk daftar atau kamus bersarang

Item hashable mengacu pada item yang memiliki nilai hash yang tidak pernah berubah selama masa pakainya. Diskusi lengkap tentang ini berada di luar cakupan tutorial ini. Jika Anda tertarik, Anda dapat melihat dokumentasi resmi di

Untuk menemukan persimpangan dua daftar dengan Python, kita dapat mengonversi daftar menjadi set dan menggunakan operator

<name of set>.intersection(<names of interables>)

1 bawaan atau metode

<name of set>.intersection(<names of interables>)

Mari kita lihat beberapa contoh

Mengubah daftar menjadi set dan menggunakan operator &

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Di sini, pertama-tama kita menyatakan dua daftar –

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 – pada baris 1 dan 2

Selanjutnya, pada baris 4 dan 5, kami menggunakan fungsi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

3 untuk mengubah daftar menjadi set

Pada baris 7, kami menggunakan operator

<name of set>.intersection(<names of interables>)

_1 untuk menemukan persimpangan antara dua himpunan. Operator ini mengembalikan set baru dengan elemen yang sama untuk

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

5 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

6. Kami meneruskan set yang dihasilkan ini ke fungsi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

_7 untuk mengubahnya kembali ke daftar dan menetapkan daftar yang dihasilkan ke

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Terakhir, kami mencetak nilai

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

8 pada baris 9

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

[3, 4, 5]

Mengubah daftar menjadi set dan menggunakan metode interseksi()

Selanjutnya, mari kita lihat contoh yang menggunakan metode

<name of set>.intersection(<names of interables>)

Sementara operator

<name of set>.intersection(<names of interables>)

_1 hanya dapat digunakan pada dua set, metode

<name of set>.intersection(<names of interables>)

2 dapat digunakan dengan jenis iterable lainnya, seperti daftar atau tuple

Sintaksnya adalah sebagai berikut

<name of set>.intersection(<names of interables>)

Mari kita lihat sebuah contoh

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Di sini, kami hanya mengonversi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

_1 menjadi satu set. Ini karena kami dapat memberikan daftar (mis. g.

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2) langsung ke metode

<name of set>.intersection(<names of interables>)

2, tanpa harus mengubah daftar menjadi satu set

Kami melakukannya pada baris 6, di mana kami menggunakan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

5 untuk memanggil metode

<name of set>.intersection(<names of interables>)

2 dan meneruskan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 sebagai argumen untuk metode

Metode ini mengembalikan satu set. Kami mengonversi set kembali ke daftar menggunakan fungsi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

7, dan menetapkan hasilnya ke

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Terakhir, kami mencetak nilai

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

8 pada baris 8

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

[3, 4, 5]

Terjadi kesalahan saat mengonversi daftar menjadi kumpulan

Last but not least, mari kita lihat contoh di mana kita tidak dapat mengonversi daftar menjadi kumpulan. Itu terjadi ketika satu atau lebih item dalam daftar tidak dapat di-hash. Misalnya, jika daftar memiliki daftar bersarang (yang tidak dapat di-hash), kita akan mendapatkan kesalahan saat mencoba mengonversi daftar menjadi kumpulan

list1 = [1, 2, 3, 4, 5, [7, 8, 9]]

set1 = set(list1)

Jika Anda menjalankan kode di atas, Anda akan mendapatkan kesalahan berikut

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

Menggunakan pemahaman daftar

Pada bagian sebelumnya, kita melihat bagaimana kita dapat mengonversi daftar menjadi set dan menggunakan operator

<name of set>.intersection(<names of interables>)

1 atau metode

<name of set>.intersection(<names of interables>)

2 untuk menemukan perpotongan dua daftar dengan Python

Namun, kami juga melihat bagaimana hal itu bisa gagal saat daftar kami berisi item yang tidak dapat di-hash (seperti daftar bersarang)

Dalam kasus seperti itu, kita dapat menggunakan pemahaman daftar untuk menemukan perpotongan dua daftar. Ini tidak mengharuskan kami untuk mengonversi daftar apa pun menjadi satu set

Untuk melakukan itu, kita perlu memahami terlebih dahulu. Jika Anda tidak terbiasa dengan pemahaman daftar, Anda mungkin ingin merujuk ke beberapa posting sebelumnya, seperti dan

Singkatnya, salah satu cara yang mungkin untuk menggunakan pemahaman daftar adalah dengan menggunakan sintaks berikut

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

Menggunakan pemahaman daftar untuk membuat daftar persimpangan baru

Misalkan kita memiliki dua daftar –

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Jika kita ingin menambahkan item di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

_2 ke daftar baru bernama

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

8, hanya jika item di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 juga ada di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1, kita dapat menggunakan kode di bawah ini

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]

intersect = [x for x in list2 if x in list1]
print(intersect)

Baris 4 pada kode di atas mengatakan bahwa untuk setiap item di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 (

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

1), tambahkan item (

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

2) ke

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

8 jika item tersebut di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 (

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Ini memberi kita persimpangan dari dua daftar –

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Menggunakan pemahaman daftar untuk menemukan persimpangan dua daftar dengan daftar bersarang

Selanjutnya, mari kita lihat contoh lain di mana daftar berisi daftar bersarang

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Ini menunjukkan bahwa pemahaman daftar berfungsi bahkan dengan daftar bersarang

Menggunakan fungsi filter() bawaan

Last but not least, mari kita lihat metode ketiga untuk menemukan persimpangan dua daftar di Python – menggunakan fungsi

[3, 4, 5]

Fungsi

[3, 4, 5]

7 adalah fungsi bawaan di Python yang menerima dua argumen - fungsi yang menentukan kriteria untuk memfilter dan iterable untuk difilter

Misalkan kita memiliki daftar yang disebut

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

_0, didefinisikan sebagai berikut

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Jika kita ingin memfilter semua bilangan genap dalam daftar, kita dapat menentukan fungsi yang mengembalikan

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

1 saat melewati bilangan genap

Kami kemudian dapat meneruskan fungsi ini dan daftar

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

0 ke fungsi

[3, 4, 5]

Mari kita lihat contoh cara kerjanya

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Di sini, pertama-tama kita mendefinisikan daftar

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

0 pada baris 1

Selanjutnya, kita mendefinisikan fungsi yang disebut

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

_5 yang menerima satu argumen

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

2 dan mengembalikan

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

1 jika

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

2 genap (i. e. jika

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

_2 memberikan sisa nol bila dibagi 2)

Selanjutnya, kita memanggil fungsi

[3, 4, 5]

7 pada baris 7, meneruskan nama fungsi (

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]

intersect = [x for x in list2 if x in list1]
print(intersect)

1) dan nama iterable (

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

0) ke fungsi

Fungsi

[3, 4, 5]

7 mengembalikan objek filter yang dapat dikonversi menjadi daftar, menggunakan fungsi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

7 bawaan

Kami melakukannya pada baris 7 dan menugaskan daftar yang dihasilkan ke variabel yang disebut

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]

intersect = [x for x in list2 if x in list1]
print(intersect)

Terakhir, kami mencetak nilai

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]

intersect = [x for x in list2 if x in list1]
print(intersect)

_5 dan

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

0 pada baris 9 dan 10

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

list1 = [1, 2, 3, 4]
list2 = [3, 4, 5, 6]

intersect = [x for x in list2 if x in list1]
print(intersect)

5 hanya berisi angka genap karena ini adalah item di

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

_0 yang "lulus" kriteria filter, sebagaimana ditentukan oleh fungsi

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

0, di sisi lain, tidak berubah setelah kami meneruskannya ke fungsi

[3, 4, 5]

Seperti disebutkan sebelumnya, kita dapat menggunakan fungsi

[3, 4, 5]

7 untuk menemukan persimpangan dua daftar di Python. Mari kita lihat beberapa contoh

Menggunakan fungsi filter() untuk menemukan persimpangan dua daftar dengan Python

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Di sini, pertama kita mendefinisikan fungsi yang disebut

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

04 pada baris 4 sampai 6. Fungsi ini mengembalikan

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

1 jika

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

2 ada di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Selanjutnya, kami menggunakan fungsi untuk memfilter

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 pada baris 8. Kami juga meneruskan objek filter yang dihasilkan ke fungsi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

7 untuk mengubahnya menjadi daftar

Terakhir, kami mencetak nilai dari daftar yang dihasilkan pada baris 10

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Menggunakan fungsi filter() dengan fungsi lambda

Selanjutnya, mari kita lihat satu lagi contoh penggunaan fungsi

[3, 4, 5]

7 untuk menemukan persimpangan dua daftar di Python. Kali ini, alih-alih meneruskan fungsi bernama ke fungsi, kami akan meneruskan fungsi lambda. Jika Anda tidak terbiasa dengan fungsi lambda, Anda bisa

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Di sini, fungsi lambda adalah

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Fungsi mengevaluasi ekspresi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_11 untuk setiap input

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

2 dan mengembalikan

[<item to add to new list> <for loop to iterate through existing list> <if condition>]

1 jika

Traceback (most recent call last):
  File "...", line ..., in <module>
    set1 = set(list1)
TypeError: unhashable type: 'list'

2 ada di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Kami meneruskan fungsi lambda ini ke fungsi

[3, 4, 5]

_7 di baris 4 untuk memfilter item di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Tidak mengherankan, contoh ini memberikan keluaran yang sama dengan contoh sebelumnya karena fungsi lambda-nya melakukan hal yang sama dengan fungsi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_04 pada contoh sebelumnya

Metode Mana yang Digunakan?

Sekarang kita telah membahas tiga metode berbeda untuk menemukan persimpangan dua daftar dengan Python, mari kita bahas beberapa faktor yang perlu dipertimbangkan saat memilih metode mana yang akan digunakan

Faktor pertama yang perlu dipertimbangkan adalah apakah daftar Anda berisi item yang tidak dapat di-hash (seperti daftar bersarang)

Jika ya, Anda harus menggunakan pemahaman daftar atau fungsi

[3, 4, 5]

Selanjutnya, faktor kedua yang perlu dipertimbangkan adalah apakah daftar Anda memiliki item duplikat. Jika daftar Anda memiliki item duplikat dan Anda ingin persimpangan memperhitungkan item ini, tidak ada metode di atas yang ideal

Mari kita lihat beberapa contoh

[3, 4, 5]

Jika Anda menjalankan kode di atas, Anda akan mendapatkan output berikut

[3, 4, 5]

Saat kami mengonversi daftar menjadi satu set, item duplikat dihapus. Misalnya, jika

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

20,

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

21 memberi kita himpunan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Oleh karena itu, pada contoh pertama di atas, ketika kita mengonversi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 menjadi himpunan, dan menggunakan operator

<name of set>.intersection(<names of interables>)

1 atau metode

<name of set>.intersection(<names of interables>)

2 untuk menemukan persimpangan dari dua himpunan, himpunan yang dihasilkan tidak mengandung item duplikat

Oleh karena itu, kita mendapatkan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

27 sebagai output untuk

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

28 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Selanjutnya, untuk contoh kedua, perhatikan bahwa kita mendapatkan jawaban yang berbeda untuk

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

30 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

31?

Hal ini karena untuk

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

30, kami beralih melalui

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 untuk memeriksa apakah item juga ada di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2. Di sisi lain, untuk

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

31, kami beralih melalui

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 untuk memeriksa apakah item juga ada di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Ini memberi kita hasil yang berbeda karena hasil untuk

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

30 didasarkan pada

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1. Oleh karena itu, angka 3 muncul dua kali dalam

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

30 karena ada dua angka 3 dalam

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1. Demikian pula, angka 5 muncul dua kali karena ada dua angka 5 di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Sebaliknya, hasil untuk

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_31 didasarkan pada

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2. Oleh karena itu, angka 3 muncul tiga kali pada

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

31 sedangkan angka 5 muncul satu kali

Perbedaan jawaban yang sama dapat ditemukan ketika kita menggunakan fungsi

[3, 4, 5]

7 untuk menemukan persimpangan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 (lihat contoh 3)

Jika kita tidak menginginkan perbedaan seperti itu dalam jawaban kita, kita perlu menulis fungsi kita sendiri

Ini membawa kita ke soal latihan untuk hari ini

Latihan Soal

Soal latihan hari ini adalah menulis fungsi bernama

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

49 yang menerima dua daftar sebagai argumen. Kita dapat berasumsi bahwa kedua daftar tersebut hanya berisi item hashable

Fungsi menemukan persimpangan dari dua daftar, berdasarkan berapa kali item muncul di kedua daftar .

Misalnya, misalkan kita memiliki daftar

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

50 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

51, fungsi kita harus mengembalikan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

52 sebagai hasilnya

Meskipun 1 muncul tiga kali di daftar kedua, itu hanya muncul dua kali di daftar pertama. Oleh karena itu, 1 muncul dua kali di persimpangan

Demikian pula, meskipun 2 muncul tiga kali di daftar pertama, hanya muncul sekali di daftar kedua. Oleh karena itu, 2 muncul sekali di persimpangan

Seperti yang Anda lihat, persimpangan tidak didasarkan pada daftar pertama atau kedua. Sebaliknya, ini didasarkan pada berapa kali item muncul di kedua daftar .

Hasil yang diharapkan

Untuk menguji fungsi Anda, Anda dapat menjalankan pernyataan berikut

[3, 4, 5]

Jika Anda menjalankan kode di atas, Anda harus mendapatkan output berikut

[3, 4, 5]

Petunjuk

Ada lebih dari satu cara untuk menyelesaikan soal latihan hari ini. Solusi yang disarankan menggunakan kelas

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_53 dan metode

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

54 untuk daftar

Anda mungkin ingin merujuk ke posting berikut jika Anda memerlukan bantuan

Cara menghitung kemunculan item dalam daftar
Menggunakan metode extend()

Solusi yang Disarankan

Inilah solusi yang disarankan untuk pertanyaan hari ini

Klik untuk melihat solusi yang disarankan

[3, 4, 5]

Di sini, pertama-tama kita mengimpor kelas

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_53 pada baris 1

Selanjutnya, kita mendefinisikan fungsi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_49 dari baris 3 hingga 17

Di dalam fungsi, kami meneruskan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 ke konstruktor

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

59 dan menetapkan objek

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

53 yang dihasilkan ke

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

61 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Objek

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_53 memberikan berapa kali item muncul dalam iterable

Misalnya,

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_64 memberi kita

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

53 objek

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

66, karena

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

67 muncul dua kali (

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

68) di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

69 sementara

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

70 muncul sekali (

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

71)

Jika kita menetapkan objek ini ke variabel, misalnya

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

72, kita dapat mengakses nilai di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

72 seperti cara kita mengakses nilai dalam kamus

Misalnya,

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_74 memberi kita nilai 2

Dalam solusi yang kami sarankan,

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_61 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

62 beri kami frekuensi setiap item di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

Setelah kami mendapatkan frekuensi ini, kami siap untuk menemukan persimpangan dari kedua daftar tersebut. Kami pertama kali menemukan persimpangan tanpa duplikat. Untuk melakukan itu, kami mengonversi

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

_1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 menjadi set dan menggunakan operator

<name of set>.intersection(<names of interables>)

1 untuk mendapatkan persimpangan

Selanjutnya, kami mengubah persimpangan ini menjadi daftar dan menetapkan daftar yang dihasilkan ke

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

82 (pada baris 11)

Selanjutnya, kami menginisialisasi daftar kosong bernama ________14______83

Kami kemudian menggunakan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

84 loop untuk beralih melalui

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

82 (baris 14 dan 15)

Pada baris 15,

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_86 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

87 sebutkan berapa kali

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

88 muncul di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

1 dan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)

intersect = list(set1.intersection(list2))

print(intersect)

2 masing-masing

Misalnya, misalkan

[3, 4, 5]

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_82 sama dengan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Pertama kali

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_84 loop berjalan,

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

88 sama dengan 1

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_95 memberi kita 2 sementara

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

96 memberi kita 3

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_97 memberi kita yang lebih rendah dari dua angka, yaitu 2

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_98 memberi kita

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

99, yang sama dengan

[3, 4, 5]

Kami kemudian meneruskan daftar ini ke metode

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_54 untuk menambahkannya ke

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Kami terus melakukan ini sampai kami menyelesaikan iterasi melalui semua item di

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

Ketika itu terjadi,

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_83 berisi semua item duplikat yang kita perlukan untuk persimpangan. Karenanya, kami hanya mengembalikan

list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]

set1 = set(list1)
set2 = set(list2)

intersect = list(set1 & set2)

print(intersect)

_83 pada baris 17

Bagaimana Anda memotong dua daftar dengan Python?

Contoh - .

# Program Python untuk mendapatkan persimpangan

# dari dua daftar menggunakan set() dan persimpangan()

def daftar_persimpangan(daftar1, daftar2)

set pengembalian (daftar1). persimpangan (daftar2)

daftar1 = [40, 90, 11, 58, 31, 66, 28, 54, 79]

daftar2 = [58, 90, 54, 31, 45, 11, 66, 28, 26]

cetak(intersection_list(list1, list2))

Bagaimana menemukan persimpangan dua daftar string dengan Python?

Ikuti langkah-langkah di bawah ini. .

Mengkonversi dua string menjadi set

Potong dua himpunan menggunakan metode irisan

Ubah hasilnya menjadi string menggunakan metode join

Cetak hasilnya

Bagaimana menemukan persimpangan lebih dari dua daftar dengan Python?

Solusi. Untuk memotong daftar himpunan, gunakan strategi berikut. .

Dapatkan elemen pertama dari daftar sebagai titik awal. .

Panggil metode interseksi() pada objek set pertama

Lewati semua set sebagai argumen ke dalam metode persimpangan () dengan membongkar daftar dengan daftar * operator asterisk

Apa 3 cara berbeda untuk menggabungkan 2 daftar dengan Python?

Berikut ini adalah 6 cara menggabungkan daftar dengan Python. .

gabungan (+) operator

Metode Naif

Daftar Pemahaman

memperpanjang() metode

operator '*'

itertools. rantai() metode

kode python

Persimpangan python dari dua daftar

Menggunakan set untuk menemukan persimpangan dua daftar dengan Python

Perbedaan utama antara satu set dan daftar

Mengubah daftar menjadi set dan menggunakan operator &

Mengubah daftar menjadi set dan menggunakan metode interseksi()

Terjadi kesalahan saat mengonversi daftar menjadi kumpulan

Menggunakan pemahaman daftar

Menggunakan pemahaman daftar untuk membuat daftar persimpangan baru

Menggunakan pemahaman daftar untuk menemukan persimpangan dua daftar dengan daftar bersarang

Menggunakan fungsi filter() bawaan

Menggunakan fungsi filter() untuk menemukan persimpangan dua daftar dengan Python

Menggunakan fungsi filter() dengan fungsi lambda

Metode Mana yang Digunakan?

Latihan Soal

Hasil yang diharapkan

Petunjuk

Solusi yang Disarankan

Bagaimana Anda memotong dua daftar dengan Python?

Bagaimana menemukan persimpangan dua daftar string dengan Python?

Bagaimana menemukan persimpangan lebih dari dua daftar dengan Python?

Apa 3 cara berbeda untuk menggabungkan 2 daftar dengan Python?

Pos Terkait

Periklanan

BERITA TERKINI

Toplist Popular

Periklanan

Terpopuler

Periklanan

Tentang Kami

Legal

Dukungan

Social