Cara mengalikan dua daftar dengan python menggunakan numpy

Dalam postingan ini, kita akan belajar cara membuat daftar baru dengan mengalikan item dalam dua daftar. Program ini akan melakukan perkalian index-wise i. e. item pertama dari daftar pertama akan dikalikan dengan item pertama dari daftar kedua, item kedua dari daftar pertama akan dikalikan dengan item kedua dari daftar kedua dst.

Kita dapat melakukan ini dengan cara yang berbeda. Mari kita lihat satu per satu

Metode 1. Dengan mengulangi daftar

Kami dapat mengulangi satu daftar dan dengan menggunakan indeks iterasi, kami dapat mengakses item pada indeks tersebut di daftar kedua

first_list = [1, 2, 3, 4, 5]
second_list = [2, 3, 4, 5, 6]
product_list = []

for i, v in enumerate(first_list):
    product_list.append(first_list[i] * second_list[i])

print(f'First list: {first_list}')
print(f'Second list: {second_list}')
print(f'Product list: {product_list}')

Di Sini,

• first_list dan second_list diberi daftar angka
• Iterasi melalui item first_list menggunakan for loop dan menambahkan produk item first_list dan second_list ke product_list
• Tiga baris terakhir mencetak isi dari tiga daftar yang dibuat

Jika Anda menjalankan program ini, itu akan mencetak output di bawah ini

First list: [1, 2, 3, 4, 5]
Second list: [2, 3, 4, 5, 6]
Product list: [2, 6, 12, 20, 30]

Perhatikan bahwa ini akan menimbulkan satu kesalahan jika panjang daftar kedua lebih kecil dari daftar pertama. Itu akan membuang IndexError

IndexError: list index out of range

Untuk menghindarinya, Anda dapat membungkus kode dalam blok coba-kecuali

first_list = [1, 2, 3, 4, 5]
second_list = [2, 3, 4, 5]
product_list = []

for i, v in enumerate(first_list):
    try:
        product_list.append(first_list[i] * second_list[i])
    except IndexError:
        print('Error..Lengths are unequal !!')

print(f'First list: {first_list}')
print(f'Second list: {second_list}')
print(f'Product list: {product_list}')

Ini akan mencetak

Error..Lengths are unequal !!
First list: [1, 2, 3, 4, 5]
Second list: [2, 3, 4, 5]
Product list: [2, 6, 12, 20]

Panjang daftar pertama adalah 5 dan panjang daftar kedua adalah 4. Daftar terakhir dibuat hanya untuk 4 item

Kita dapat menggunakan pemahaman daftar untuk melakukannya dengan cepat hanya dalam satu baris

first_list = [1, 2, 3, 4, 5]
second_list = [2, 3, 4, 5]
product_list = [v * second_list[i]
                for i, v in enumerate(first_list) if i < len(second_list)]

print(f'First list: {first_list}')
print(f'Second list: {second_list}')
print(f'Product list: {product_list}')

Alih-alih blok coba-kecuali, kami memeriksa apakah nilai i kurang dari panjang daftar kedua atau tidak. Ini akan memberikan output yang sama

Metode 2. Dengan menggunakan zip()

Kami dapat meneruskan daftar sebagai parameter ke metode zip. Metode ini membuat tupel baru dengan menggabungkan item-item dari list. Kita dapat kembali menggunakan metode peta untuk mengulangi ini dan menemukan produk dari item

first_list = [1, 2, 3, 4, 5]
second_list = [2, 3, 4, 5]
product_list = []

for a, b in zip(first_list, second_list):
    product_list.append(a*b)

print(f'First list: {first_list}')
print(f'Second list: {second_list}')
print(f'Product list: {product_list}')

Ini akan berfungsi bahkan jika daftar memiliki ukuran yang berbeda

Jika Anda menjalankan program ini, itu akan mencetak output di bawah ini

First list: [1, 2, 3, 4, 5]
Second list: [2, 3, 4, 5]
Product list: [2, 6, 12, 20]

Atau, kita bisa menggunakan pemahaman daftar

first_list = [1, 2, 3, 4, 5]
second_list = [2, 3, 4, 5]
product_list = [a*b for a, b in zip(first_list, second_list)]

print(f'First list: {first_list}')
print(f'Second list: {second_list}')
print(f'Product list: {product_list}')

Ini akan memberikan output yang sama

Metode 3. Dengan menggunakan fungsi map() dan list()

Kita bisa meneruskan lambda dan daftar ke fungsi peta. Ini akan membuat satu iterable baru dengan menerapkan lambda ke daftar yang diberikan. Kita dapat menggunakan list() untuk mengubahnya menjadi daftar

Program terakhir akan

first_list = [1, 2, 3, 4, 5]
second_list = [2, 3, 4, 5]
product_list = list(map(lambda a, b: a*b, first_list, second_list))

print(f'First list: {first_list}')
print(f'Second list: {second_list}')
print(f'Product list: {product_list}')

Ini akan berfungsi meskipun ukuran daftarnya berbeda

Metode 4. Dengan menggunakan numpy. perkalian() metode

numpy. perkalian tersedia di perpustakaan NumPy dan jika proyek Anda menggunakan NumPy, Anda dapat menggunakan metode perkalian untuk mengalikan dua daftar dengan mudah

Mudah digunakan dan dapat menangani daftar multi-dimensi dengan mudah. Cukup berikan daftar sebagai argumen untuk metode ini dan itu akan mengembalikan daftar produk

Sederhananya, kita harus melakukan perkalian berdasarkan elemen. Jadi, mari kita mulai

Kalikan dua Daftar di Python dengan Menggunakan Loop

Salah satu pendekatan langsung adalah mengulang kedua daftar, menghitung produk nilai pada indeks yang sama dan menambahkannya ke daftar baru. Mari kita lihat contohnya

list_one = [3, 4, 5 ,6, 8, 9]
list_two = [4, 5, 1, 0, 6]

product = []
for el1, el2 in zip(list_one, list_two):
  product.append(el1*el2)
  

print("The product of two lists is: ", product)

Keluaran

The product of two lists is:  [12, 20, 5, 0, 48]

Dalam contoh di atas, kami mengulangi daftar menggunakan metode zip(). Dibutuhkan iterables (daftar) dan mengembalikan iterator tupel

Selain itu, pastikan untuk menjalankan perulangan sebanyak n kali, di mana n adalah panjang dari daftar yang lebih kecil

Metode zip() menanganinya karena Anda dapat melihat bahwa list_one memiliki enam item dan list_two memiliki lima, tetapi daftar produk hanya memiliki lima nilai

Kalikan dua Daftar dengan Python dengan Menggunakan Pemahaman Daftar

Kita juga dapat menggunakan pemahaman daftar untuk melakukan perkalian berdasarkan elemen. Metode ini harus lebih disukai daripada yang sebelumnya karena lebih mudah dan ringkas. Ayo lihat

list_one = [3, 4, 5 ,6, 8, 9]
list_two = [4, 5, 1, 0, 6]

product = [el1*el2 for el1, el2 in zip(list_one, list_two)] #element-wise multiplication

print("The product of two lists is: ", product)

Keluaran

The product of two lists is:  [12, 20, 5, 0, 48]

Lihat, ini adalah pendekatan singkat dan sederhana

Kalikan dua Daftar di Python dengan Menggunakan NumPy

Metode lain adalah dengan menggunakan perpustakaan NumPy. Pertama, kami mengonversi kedua daftar menjadi array NumPy atau ndarrays, mis. e. , arr1 dan arr2

Kemudian, kita mengalikan dua larik seperti yang kita lakukan dengan angka, i. e. , arr1*arr2. Terakhir, kami mengubah ndarray menjadi daftar

Namun, panjang kedua daftar harus sama. Jika tidak, kita akan mendapatkan kesalahan. Ayo lihat

import numpy as np

list_one = [3, 4, 5 ,6, 8, 9]
list_two = [4, 5, 1, 0, 6,]
n = min(len(list_one), len(list_two)) #get the minimum length

#convert to numpy arrays
arr1 = np.array(list_one)
arr2 = np.array(list_two)

product = arr1[:n]*arr2[:n] #element-wise multiplication

#convert numpy array to list
product = product.tolist()
print("The product of two lists is: ", product)

Keluaran

The product of two lists is:  [12, 20, 5, 0, 48]

Di sini, kita mengambil panjang dari larik yang lebih kecil dan hanya mengalikan jumlah elemen tersebut

NumPy adalah perpustakaan yang kuat untuk perhitungan ilmiah. Ini menyediakan beberapa metode dan alat untuk membuat dan bekerja dengan array secara efisien

Oleh karena itu, jika kita ingin menghitung produk berdasarkan elemen dari data besar, maka menggunakan NumPy akan sangat efisien

Marcel

Hai teman-teman. Ini aku, Marcel, alias Maschi. Di MaschiTuts, semuanya tentang tutorial. Apa pun topik artikelnya, tujuannya selalu tetap sama. Memberi kalian tutorial yang paling mendalam dan bermanfaat

Bagaimana Anda mengalikan dua elemen daftar

Bagaimana cara mengalikan 2 array NumPy?

Bagaimana Anda menyilangkan dua daftar dengan Python?

Bagaimana Anda mengalikan dua daftar string dengan Python?