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:
- Sử dụng chức năng
1 để có được một bộ dữ liệu với các mục tương ứ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
- Sử dụng một danh sách hiểu để lặp lại trên Itable.
- Trên mỗi lần lặp, truyền tuple đến hàm
2.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]
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
3 lặp lại trên các bộ dữ liệu, lấy 1 mục từ mỗi bộ phận.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ố
4 và bộ thứ hai bao gồm các phần tử trong mỗi tuple 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
5.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
1 và tổng hợp mỗi tuple.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
2 và nhận tổng số.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]