Jumlah tuple mutlak dalam Python

Dalam Python, tupel ialah jujukan tidak berubah yang boleh menyimpan berbilang elemen pelbagai jenis. Ia sering digunakan untuk mewakili koleksi nilai yang berkaitan. Penjumlahan tuple melibatkan penambahan elemen sepadan dua atau lebih tupel untuk menghasilkan tupel baharu. Walau bagaimanapun, dalam sesetengah senario, anda mungkin perlu mengira jumlah mutlak unsur dan bukannya jumlah tradisional. Dalam catatan blog ini, kami akan meneroka cara melakukan jumlah tuple mutlak dalam Python.

Penjumlahan tupel tradisional

Sebelum kita mendalami jumlah tuple mutlak, mari kita fahami dahulu cara membuat jumlah tuple tradisional. Memandangkan dua tupel yang sama panjang, kita boleh menggunakan gelung Python mudah atau pemahaman senarai untuk mengira jumlah elemen yang sepadan −

def tuple_sum(t1, t2):
   return tuple(a + b for a, b in zip(t1, t2))

Contoh penjumlahan tuple tradisional

t1 = (2, -4, 6)
t2 = (-1, 3, 5)
result = tuple_sum(t1, t2)
print(result)  # Output: (1, -1, 11)

Dalam kod di atas, fungsi zip menggandingkan elemen t1 dan t2, dan pemahaman senarai mengira jumlah setiap pasangan elemen. Nilai yang terhasil kemudiannya ditukarkan semula ke dalam tuple menggunakan fungsi tuple().

Jumlah mutlak tupel

Penjumlahan tuple mutlak melibatkan pengambilan nilai mutlak jumlah unsur yang sepadan dalam dua atau lebih tupel. Untuk melakukan ini, kita boleh mengubah suai kod sebelumnya dengan menambahkan fungsi abs() −

def absolute_tuple_sum(t1, t2):
   return tuple(abs(a + b) for a, b in zip(t1, t2))

Contoh jumlah tuple mutlak

t1 = (2, -4, 6)
t2 = (-1, 3, 5)
result = absolute_tuple_sum(t1, t2)
print(result)  # Output: (1, 7, 11)

Fungsi

abs() mengira nilai mutlak sesuatu nombor, memastikan keputusan sentiasa bukan negatif.

Mengendalikan tupel yang berbeza panjang

Dalam sesetengah kes, kita mungkin ingin mengira jumlah tuple mutlak bagi tupel dengan panjang yang berbeza. Satu pendekatan ialah memotong tuple yang lebih panjang kepada panjang yang sepadan dengan tuple yang lebih pendek. Kita boleh mencapai ini menggunakan fungsi itertools.zip_longest(), yang mengisi elemen yang hilang dengan nilai lalai (0 dalam kes ini) −

from itertools import zip_longest

def absolute_tuple_sum(t1, t2):
   return tuple(abs(a + b) for a, b in zip_longest(t1, t2, fillvalue=0))

Fungsi

zip_longest() memastikan lelaran berhenti apabila tuple terpanjang habis, menggantikan mana-mana elemen yang hilang dengan 0s. Dengan cara ini, pengiraan jumlah mutlak masih berfungsi.

Contoh penggunaan

Mari lihat penjumlahan tuple mutlak dalam tindakan dengan beberapa contoh −

t1 = (2, -4, 6)
t2 = (-1, 3, 5)
result = absolute_tuple_sum(t1, t2)
print(result)  # Output: (1, 7, 11)

t3 = (1, 2, 3, 4)
t4 = (5, 6, 7)
result = absolute_tuple_sum(t3, t4)
print(result)  # Output: (6, 8, 10, 4)

Dalam contoh pertama, unsur t1 dan t2 yang sepadan ditambah, menghasilkan tupel (1, 7, 11). Contoh kedua menunjukkan pengendalian tupel dengan panjang yang berbeza. Tuple yang lebih panjang t3 dipotong untuk memadankan panjang t4, menghasilkan tupel (6, 8, 10, 4).

Ralat pengendalian input tidak sah

Apabila melakukan jumlah tuple mutlak, adalah penting untuk mengendalikan kes di mana tupel input mempunyai panjang yang berbeza atau bukan tupel yang sah. Satu cara ialah menyemak panjang tupel sebelum melakukan jumlah dan menimbulkan pengecualian jika ia tidak serasi. Selain itu, anda boleh menambah semakan untuk memastikan bahawa nilai input sebenarnya adalah tupel. Contoh berikut menunjukkan cara untuk memasukkan pengendalian ralat ke dalam kod anda −

def absolute_tuple_sum(t1, t2):
   if not isinstance(t1, tuple) or not isinstance(t2, tuple):
      raise TypeError("Inputs must be tuples.")
   if len(t1) != len(t2):
      raise ValueError("Tuples must have the same length.")

   return tuple(abs(a + b) for a, b in zip_longest(t1, t2, fillvalue=0))

Contoh pengendalian ralat untuk input tidak sah

t5 = (1, 2, 3)
t6 = (4, 5, 6, 7)
result = absolute_tuple_sum(t5, t6)  # Raises ValueError: Tuples must have the same length.

t7 = [1, 2, 3]
t8 = (4, 5, 6)
result = absolute_tuple_sum(t7, t8)  # Raises TypeError: Inputs must be tuples.

Fungsi yang menyamaratakan berbilang tupel

Contoh yang ditunjukkan dalam catatan blog memfokuskan pada pengiraan jumlah mutlak dua tupel. Walau bagaimanapun, fungsi ini boleh digeneralisasikan dengan mudah untuk mengendalikan berbilang tupel. Dengan menggunakan argumen *args dalam definisi fungsi, anda boleh menghantar sebarang bilangan tupel sebagai argumen dan jumlah mutlaknya dikira. Di bawah ialah versi terkini fungsi −

def absolute_tuple_sum(*tuples):
   if any(not isinstance(t, tuple) for t in tuples):
      raise TypeError("All inputs must be tuples.")
   if len(set(len(t) for t in tuples)) != 1:
      raise ValueError("All tuples must have the same length.")

   return tuple(abs(sum(elements)) for elements in zip_longest(*tuples, fillvalue=0))

Fungsi yang menyamaratakan contoh tupel

t9 = (1, 2, 3)
t10 = (4, 5, 6)
t11 = (7, 8, 9)
result = absolute_tuple_sum(t9, t10, t11)
print(result)  # Output: (12, 15, 18)

Fungsi diubah suai ini membolehkan anda mengira jumlah tupel mutlak sebarang bilangan tupel dengan hanya menghantar tupel sebagai argumen kepada fungsi tersebut.

Pertimbangan prestasi

Prestasi boleh menjadi isu apabila berurusan dengan tupel besar atau jumlah tupel yang banyak. Dalam kes ini, mungkin lebih cekap menggunakan NumPy, perpustakaan pengkomputeran berangka yang berkuasa dalam Python. NumPy menyediakan fungsi yang dioptimumkan untuk operasi tatasusunan, termasuk penjumlahan nilai mutlak dari segi unsur. Dengan menukar tupel kepada tatasusunan NumPy, anda boleh memanfaatkan fungsi pengoptimuman ini, yang berpotensi mencapai prestasi yang lebih baik. Berikut ialah contoh yang menunjukkan cara memanfaatkan NumPy −

import numpy as np

def absolute_tuple_sum(*tuples):
   if any(not isinstance(t, tuple) for t in tuples):
      raise TypeError("All inputs must be tuples.")
   if len(set(len(t) for t in tuples)) != 1:
      raise ValueError("All tuples must have the same length.")

   arrays = [np.array(t) for t in tuples]
   result = np.sum(arrays, axis=0)
   return tuple(np.abs(result))

Contoh pertimbangan prestasi

t12 = tuple(range(1000000))  # A large tuple of size 1,000,000
t13 = tuple(range(1000000, 0, -1))  # Another large tuple with elements in reverse order

result = absolute_tuple_sum(t12, t13)
print(result)  # Output: (999999, 999999, 999999, ..., 999999) (a tuple of all 999999's)

# Using NumPy for performance optimization
import numpy as np

t12_np = np.array(t12)
t13_np = np.array(t13)

result_np = np.abs(t12_np + t13_np)
print(tuple(result_np))  # Output: (999999, 999999, 999999, ..., 999999) (same as the previous output)

Dengan memanfaatkan NumPy, anda selalunya boleh meningkatkan prestasi pengiraan berskala besar dengan ketara.

Kesimpulan

Kami telah meneroka konsep jumlah tuple mutlak dalam Python. Kami belajar cara mengira jumlah mutlak unsur yang sepadan dalam dua atau lebih tupel. Coretan kod yang disediakan menunjukkan penjumlahan tupel tradisional, pengendalian tupel dengan panjang yang berbeza dan pengendalian ralat untuk input yang tidak sah. Kami juga membincangkan pengitlak fungsi untuk menyokong berbilang tupel dan mempertimbangkan pengoptimuman prestasi untuk pengiraan berskala besar menggunakan NumPy.

Atas ialah kandungan terperinci Jumlah tuple mutlak dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!