Hướng dẫn add two tuples together python - thêm hai bộ mã với nhau python

W3Schools được tối ưu hóa cho việc học và đào tạo. Ví dụ có thể được đơn giản hóa để cải thiện việc đọc và học tập. Hướng dẫn, tài liệu tham khảo và ví dụ được xem xét liên tục để tránh lỗi, nhưng chúng tôi không thể đảm bảo tính chính xác đầy đủ của tất cả các nội dung. Trong khi sử dụng W3Schools, bạn đồng ý đã đọc và chấp nhận các điều khoản sử dụng, cookie và chính sách bảo mật của chúng tôi.

Bản quyền 1999-2022 bởi dữ liệu refsnes. Đã đăng ký Bản quyền. W3Schools được cung cấp bởi W3.CSS.
W3Schools is Powered by W3.CSS.

Để có được hành vi "+" và "+=" của bạn, bạn có thể xác định lớp của riêng mình và thực hiện phương thức __add__(). Sau đây là một mẫu chưa hoàn chỉnh:

# T.py
class T(object):
    def __init__(self, *args):
        self._t = args
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self._t, other._t)]))
    def __str__(self):
        return str(self._t)
    def __repr__(self):
        return repr(self._t)

>>> from T import T
>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)

Chỉnh sửa: Tôi đã tìm thấy một cách tốt hơn ...

Xác định lớp T là một lớp con của tuple và ghi đè các phương thức __new__ và __add__. Điều này cung cấp giao diện tương tự như lớp tuple (nhưng với hành vi khác nhau cho __add__), vì vậy các trường hợp của lớp T có thể được chuyển cho bất cứ điều gì mong đợi một tuple.

class T(tuple):
    def __new__(cls, *args):
        return tuple.__new__(cls, args)
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self, other)]))
    def __sub__(self, other):
        return self.__add__(-i for i in other)

>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)
>>> 
>>> c = a + b
>>> c[0]
60
>>> c[-1]
60
>>> for x in c:
...     print x
... 
60
40
60

Thêm hai phần tử khôn ngoan trong Python #

Để thêm hai phần tử Tuples-Wise:

1. Sử dụng chức năng

   class T(tuple):
       def __new__(cls, *args):
           return tuple.__new__(cls, args)
       def __add__(self, other):
           return T(*([sum(x) for x in zip(self, other)]))
       def __sub__(self, other):
           return self.__add__(-i for i in other)
   
   >>> a = T(50, 50)
   >>> b = T(3, -5)
   >>> a
   (50, 50)
   >>> b
   (3, -5)
   >>> a+b
   (53, 45)
   >>> a+=b
   >>> a
   (53, 45)
   >>> a = T(50, 50, 50)
   >>> b = T(10, -10, 10)
   >>> a+b
   (60, 40, 60)
   >>> a+b+b
   (70, 30, 70)
   >>> 
   >>> c = a + b
   >>> c[0]
   60
   >>> c[-1]
   60
   >>> for x in c:
   ...     print x
   ... 
   60
   40
   60
   

   1 để có được một bộ dữ liệu với các mục tương ứng.
2. Sử dụng một danh sách hiểu để lặp lại trên Itable.
3. Trên mỗi lần lặp, truyền tuple đến hàm

   class T(tuple):
       def __new__(cls, *args):
           return tuple.__new__(cls, args)
       def __add__(self, other):
           return T(*([sum(x) for x in zip(self, other)]))
       def __sub__(self, other):
           return self.__add__(-i for i in other)
   
   >>> a = T(50, 50)
   >>> b = T(3, -5)
   >>> a
   (50, 50)
   >>> b
   (3, -5)
   >>> a+b
   (53, 45)
   >>> a+=b
   >>> a
   (53, 45)
   >>> a = T(50, 50, 50)
   >>> b = T(10, -10, 10)
   >>> a+b
   (60, 40, 60)
   >>> a+b+b
   (70, 30, 70)
   >>> 
   >>> c = a + b
   >>> c[0]
   60
   >>> c[-1]
   60
   >>> for x in c:
   ...     print x
   ... 
   60
   40
   60
   

   2.

main.py

Copied!
tuple_1 = (1, 2, 3)
tuple_2 = (4, 5, 6)

# 👇️ [(1, 4), (2, 5), (3, 6)]
print(list(zip(tuple_1, tuple_2)))

result = [sum(tup) for tup in zip(tuple_1, tuple_2)]

print(result)  # 👉️ [5, 7, 9]

Hàm zip lặp lại trên một số vòng lặp song song và tạo ra các bộ dữ liệu với một mục từ mỗi mục có thể.

main.py

Copied!
tuple_1 = (1, 2, 3)
tuple_2 = (4, 5, 6)

# 👇️ [(1, 4), (2, 5), (3, 6)]
print(list(zip(tuple_1, tuple_2)))

Bạn có thể tưởng tượng rằng hàm

class T(tuple):
    def __new__(cls, *args):
        return tuple.__new__(cls, args)
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self, other)]))
    def __sub__(self, other):
        return self.__add__(-i for i in other)

>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)
>>> 
>>> c = a + b
>>> c[0]
60
>>> c[-1]
60
>>> for x in c:
...     print x
... 
60
40
60

Bộ phận đầu tiên trong danh sách bao gồm các phần tử trong mỗi bộ có chỉ số

class T(tuple):
    def __new__(cls, *args):
        return tuple.__new__(cls, args)
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self, other)]))
    def __sub__(self, other):
        return self.__add__(-i for i in other)

>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)
>>> 
>>> c = a + b
>>> c[0]
60
>>> c[-1]
60
>>> for x in c:
...     print x
... 
60
40
60

class T(tuple):
    def __new__(cls, *args):
        return tuple.__new__(cls, args)
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self, other)]))
    def __sub__(self, other):
        return self.__add__(-i for i in other)

>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)
>>> 
>>> c = a + b
>>> c[0]
60
>>> c[-1]
60
>>> for x in c:
...     print x
... 
60
40
60

Bước cuối cùng là sử dụng danh sách hiểu biết để lặp lại đối tượng

class T(tuple):
    def __new__(cls, *args):
        return tuple.__new__(cls, args)
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self, other)]))
    def __sub__(self, other):
        return self.__add__(-i for i in other)

>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)
>>> 
>>> c = a + b
>>> c[0]
60
>>> c[-1]
60
>>> for x in c:
...     print x
... 
60
40
60

main.py

Copied!
tuple_1 = (1, 2, 3)
tuple_2 = (4, 5, 6)

# 👇️ [(1, 4), (2, 5), (3, 6)]
print(list(zip(tuple_1, tuple_2)))

result = [sum(tup) for tup in zip(tuple_1, tuple_2)]

print(result)  # 👉️ [5, 7, 9]

Danh sách các hệ thống được sử dụng để thực hiện một số hoạt động cho mọi yếu tố hoặc chọn một tập hợp con của các phần tử đáp ứng một điều kiện.

Hàm tổng có thể lặp lại, tổng số các mục của nó từ trái sang phải và trả về tổng số.

Trên mỗi lần lặp, chúng tôi chuyển bộ tuple hiện tại đến hàm

class T(tuple):
    def __new__(cls, *args):
        return tuple.__new__(cls, args)
    def __add__(self, other):
        return T(*([sum(x) for x in zip(self, other)]))
    def __sub__(self, other):
        return self.__add__(-i for i in other)

>>> a = T(50, 50)
>>> b = T(3, -5)
>>> a
(50, 50)
>>> b
(3, -5)
>>> a+b
(53, 45)
>>> a+=b
>>> a
(53, 45)
>>> a = T(50, 50, 50)
>>> b = T(10, -10, 10)
>>> a+b
(60, 40, 60)
>>> a+b+b
(70, 30, 70)
>>> 
>>> c = a + b
>>> c[0]
60
>>> c[-1]
60
>>> for x in c:
...     print x
... 
60
40
60

Bạn cũng có thể sử dụng phương pháp này để thêm nhiều hơn hai phần tử Tuples.

main.py

Copied!
tuple_1 = (1, 2, 3)
tuple_2 = (4, 5, 6)
tuple_3 = (7, 8, 9)

# 👇️ [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
print(list(zip(tuple_1, tuple_2, tuple_3)))

result = [sum(tup) for tup in zip(tuple_1, tuple_2, tuple_3)]

print(result)  # 👉️ [12, 15, 18]

Bạn có thể thêm 2 bộ dữ liệu trong Python không?

Làm thế nào để bạn tổng hợp hai bộ dữ liệu trong Python?

Tôi có thể thêm 2 bộ dữ liệu không?

Làm thế nào để bạn thêm hai bộ dữ liệu vào một yếu tố?