Hướng dẫn increment value in array python - giá trị gia tăng trong python mảng

Lần đầu tiên tôi đã viết điều này như một nhận xét nhưng tôi muốn mở rộng nó một chút, đặc biệt là để thêm ví dụ về tuple.

Câu trả lời của Mark Tolonen là chính xác [và được nâng cấp] trong đó các số nguyên thông thường là bất biến [không thể thay đổi] và danh sách có thể thay đổi [có thể có các yếu tố được thay thế], nhưng không đề cập đến một vài khái niệm chính khác, hiển thị trong các ví dụ hơi đáng sợ:

1. Các đối tượng bị ràng buộc với các biến.

   Bài tập biến thông thường như

   >>> [].__setitem__
   
   

   1 chỉ đơn giản là liên kết đối tượng ở bên phải, có thể được xây dựng tại chỗ nếu cần thiết với tên bên trái.

2. Các toán tử "tại chỗ" như

   >>> [].__setitem__
   
   

   2 Cố gắng gọi các chức năng sửa đổi, cho phép các đối tượng có thể thay đổi để nắm bắt chúng. Chẳng hạn, nếu

   >>> [].__setitem__
   
   

   3 bị ràng buộc với một phiên bản lớp, viết

   >>> [].__setitem__
   
   

   4 sẽ thực sự thực thi

   >>> [].__setitem__
   
   

   5, nếu

   >>> [].__setitem__
   
   

   3 có ________ 17.1 nếu không, nó sẽ chạy

   >>> [].__setitem__
   
   

   8 thay vào đó, sẽ gọi nhà điều hành

   >>> [].__setitem__
   
   

   9:

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   0. Xem tài liệu của nhà điều hành để biết tất cả các chi tiết Gory. Trong trường hợp này, các đối tượng liên quan đến các số nguyên khác thường, không có chức năng sửa đổi:

   >>> [3].__add__
   
   >>> [3].__iadd__
   Traceback [most recent call last]:
     File "", line 1, in 
   AttributeError: 'int' object has no attribute '__iadd__'
   

   Vì vậy, sự thay đổi đặc biệt này là không liên quan đối với

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   1, nhưng nó đáng nhớ.

3. Bài tập được lập chỉ mục,

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   2, gọi phương thức

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   3. Đây là cách các đối tượng có thể thay đổi [có thể sửa đổi] tự biến đổi. Một đối tượng danh sách thực hiện

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   3:

   >>> [].__setitem__
   
   

   Để hoàn thiện, tôi sẽ lưu ý rằng nó cũng thực hiện

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   5 để lấy

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   6.

   Do đó, khi bạn viết

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   7, bạn sẽ gọi điện thoại:

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   Đó là cách Python quản lý để thêm 5 vào phần tử Ith của danh sách bị ràng buộc với

   a.__setitem__[i, a.__getitem__[i] + 5]
   

   8.

Đây là ví dụ hơi đáng sợ. Một đối tượng tuple không thể sửa đổi, nhưng một đối tượng danh sách là. Nếu chúng ta nhúng một danh sách vào một tuple:

>>> l = [0]
>>> t = [l,]

Sau đó, chúng ta có thể sử dụng

a.__setitem__[i, a.__getitem__[i] + 5]

9 để gọi

>>> l = [0]
>>> t = [l,]

0 và

>>> l = [0]
>>> t = [l,]

1. Trong khi đó

a.__setitem__[i, a.__getitem__[i] + 5]

9 bị ràng buộc với cùng một đối tượng danh sách là

>>> l = [0]
>>> t = [l,]

3. Phần này là đủ rõ ràng:

>>> t
[[0],]
>>> l.append[1]
>>> t
[[0, 1],]

Chúng tôi đã sửa đổi

>>> l = [0]
>>> t = [l,]

3 tại chỗ, vì vậy

a.__setitem__[i, a.__getitem__[i] + 5]

9, tên cùng danh sách với

>>> l = [0]
>>> t = [l,]

3, đã được sửa đổi. Nhưng bây giờ:

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

Gì?! Làm thế nào mà

>>> l = [0]
>>> t = [l,]

7 thay đổi khi chúng tôi gặp lỗi cho chúng tôi biết rằng

>>> l = [0]
>>> t = [l,]

7 không thể thay đổi?

Câu trả lời là,

>>> l = [0]
>>> t = [l,]

7 không thay đổi, nhưng danh sách [mà chúng ta cũng có thể truy cập qua

>>> l = [0]
>>> t = [l,]

3] đã thay đổi. Danh sách thực hiện

>>> [].__setitem__

7, vì vậy việc chuyển nhượng:

t[0] += [2]

"means":

t.__setitem__[0, t.__getitem__[0].__iadd__[[2]]]

a.__setitem__[i, a.__getitem__[i] + 5]

5 đã truy cập danh sách và

>>> [].__setitem__

7 đã tăng cường danh sách:

>>> l
[0, 1, 2]

Và sau đó

>>> t
[[0],]
>>> l.append[1]
>>> t
[[0, 1],]

4 đã nâng

>>> t
[[0],]
>>> l.append[1]
>>> t
[[0, 1],]

5, nhưng danh sách đã được tăng cường sau đó.

Lưu ý, nhân tiện, thực tế là điều chỉnh đối tượng danh sách bị ràng buộc với

>>> l = [0]
>>> t = [l,]

3 ảnh hưởng đến đối tượng tuple bị ràng buộc với

>>> l = [0]
>>> t = [l,]

7, bởi vì

a.__setitem__[i, a.__getitem__[i] + 5]

9 là đối tượng danh sách đó. Điều này, thực tế là các biến bị ràng buộc với các đối tượng và các yếu tố trong các cấu trúc dữ liệu như bộ dữ liệu, danh sách và từ điển, có thể đề cập đến các đối tượng khác, rất quan trọng trong việc đọc và viết mã python. Hiểu cả các quy tắc ràng buộc và khi các đối tượng được tạo, là chìa khóa để biết lý do tại sao đây thường là một ý tưởng tồi:Understanding both the binding rules, and when objects get created, is the key to knowing why this is usually a bad idea:

def f[a=[]]:

Cụ thể, đối tượng danh sách ở đây được tạo vào thời gian

>>> t
[[0],]
>>> l.append[1]
>>> t
[[0, 1],]

9, tức là, chỉ một lần. Bất cứ khi nào ai đó thêm vào danh sách bên trong

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

0, ví dụ

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

1, nó tiếp tục thêm vào danh sách ban đầu đó!

Xem thêm Python: Làm thế nào ràng buộc hoạt động cho [cách quá] nhiều hơn về các quy tắc ràng buộc bổ sung. :-]

1As Duncan chỉ ra trong một bình luận về câu trả lời của Chepner, sau khi gọi

>>> [].__setitem__

7, kết quả được trả lại được giới hạn lại với đối tượng. .

Các đối tượng có thể thay đổi thường sẽ tự trả về và các đối tượng bất biến không cần phải thực hiện

>>> [].__setitem__

7 ngay từ đầu vì việc thực hiện đột biến trên một đối tượng được cho là có thể điều chỉnh có vẻ kỳ lạ. Tuy nhiên, chúng ta có thể lạm dụng, và do đó phơi bày, hành vi này bằng cách viết một lớp giả vờ là bất biến, nhưng không. Đây là một ví dụ. Điều này không có nghĩa là hữu ích, chỉ để minh họa một trong những góc tối hơn của Python.

>>> [].__setitem__

0

Khi chúng tôi tạo hai đối tượng và đóng băng lớp, chúng tôi sẽ gọi

>>> [].__setitem__

7 ba lần trên

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

6, do đó, cuối cùng,

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

6 và

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

8 thực sự bị ràng buộc với đối tượng thứ hai. Đối tượng đầu tiên chỉ có thể tin được thông qua trường

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

9 của lớp có hai mục trong danh sách của nó.

Là một bài tập, hãy cố gắng dự đoán những gì điều này sẽ in ra, trước khi chạy nó.

. cũng tại sao singletons gây tranh cãi.]

. Khi bộ này chỉ có hai yếu tố, đó là "DoubleTon". Trong Python,

t[0] += [2]

1 và

t[0] += [2]

2 là các nhân đôi bao gồm loại

t[0] += [2]

3. Việc khái quát hóa cho các đối tượng N là một đa loại, thường được khởi tạo / sử dụng như một ít nhất là cố định, sau khi "đóng băng" bảng đánh sash thời gian. Lưu ý rằng các trường hợp boolean của Python là bất biến, cũng như Singleton của Python

>>> t[0] += [2]
Traceback [most recent call last]:
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment
>>> t
[[0, 1, 2],]

3.]

Làm thế nào để bạn tăng một phần tử mảng trong Python?

Có I ++ trong Python không?

Bạn có thể làm Int ++ trong Python không?

Làm thế nào để bạn thêm 1 vào một danh sách trong Python?