Tại sao chúng ta cần bộ dữ liệu trong Python (hoặc bất kỳ loại dữ liệu bất biến nào)?

Tôi đã đọc một số hướng dẫn về python (Lặn vào Python, cho một người) và tài liệu tham khảo ngôn ngữ trên Python.org - Tôi không hiểu tại sao ngôn ngữ cần bộ dữ liệu.

Các bộ dữ liệu không có phương thức nào so với một danh sách hoặc bộ và nếu tôi phải chuyển đổi một bộ dữ liệu thành một bộ hoặc danh sách để có thể sắp xếp chúng, thì điểm đầu tiên của việc sử dụng bộ dữ liệu là gì?

Bất biến?

Tại sao mọi người quan tâm nếu một biến sống ở một nơi khác trong bộ nhớ so với khi nó được phân bổ ban đầu? Toàn bộ hoạt động kinh doanh bất biến trong Python này dường như được nhấn mạnh quá mức.

Trong C / C ++ nếu tôi phân bổ một con trỏ và trỏ đến một số bộ nhớ hợp lệ, tôi không quan tâm địa chỉ đó nằm ở đâu miễn là nó không rỗng trước khi tôi sử dụng nó.

Bất cứ khi nào tôi tham chiếu biến đó, tôi không cần biết liệu con trỏ có còn trỏ đến địa chỉ ban đầu hay không. Tôi chỉ kiểm tra null và sử dụng nó (hoặc không).

Trong Python, khi tôi phân bổ một chuỗi (hoặc tuple) gán nó cho x, sau đó sửa đổi chuỗi, tại sao tôi lại quan tâm nếu đó là đối tượng ban đầu? Miễn là biến chỉ vào dữ liệu của tôi, đó mới là vấn đề.

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

x vẫn tham chiếu dữ liệu tôi muốn, tại sao mọi người cần quan tâm nếu id của nó giống hay khác nhau?

1. đối tượng bất biến có thể cho phép tối ưu hóa đáng kể; đây có lẽ là lý do tại sao các chuỗi cũng bất biến trong Java, được phát triển khá riêng biệt nhưng cùng thời gian với Python và mọi thứ đều bất biến trong các ngôn ngữ thực sự có chức năng.

2. trong Python nói riêng, chỉ các bất biến mới có thể được băm (và do đó, các thành viên của bộ hoặc khóa trong từ điển). Một lần nữa, điều này tối ưu hóa đủ khả năng, nhưng không chỉ là "đáng kể" (thiết kế các bảng băm tốt lưu trữ các đối tượng hoàn toàn có thể thay đổi là một cơn ác mộng - hoặc bạn lấy bản sao của mọi thứ ngay khi bạn băm nó, hoặc cơn ác mộng kiểm tra xem liệu băm của đối tượng đã thay đổi kể từ lần cuối cùng bạn tham khảo về cái đầu xấu xí của nó).

Ví dụ về vấn đề tối ưu hóa:

$ python -mtimeit '["fee", "fie", "fo", "fum"]'
1000000 loops, best of 3: 0.432 usec per loop
$ python -mtimeit '("fee", "fie", "fo", "fum")'
10000000 loops, best of 3: 0.0563 usec per loop

Không có câu trả lời nào ở trên chỉ ra vấn đề thực sự của bộ dữ liệu so với danh sách, điều mà nhiều người mới sử dụng Python dường như chưa hiểu hết.

Tuples và danh sách phục vụ các mục đích khác nhau. Danh sách lưu trữ dữ liệu đồng nhất. Bạn có thể và nên có một danh sách như thế này:

["Bob", "Joe", "John", "Sam"]

Lý do sử dụng đúng danh sách là vì đó là tất cả các loại dữ liệu đồng nhất, cụ thể là tên của mọi người. Nhưng hãy lấy một danh sách như thế này:

["Billy", "Bob", "Joe", 42]

Danh sách đó là tên đầy đủ của một người và tuổi của họ. Đó không phải là một loại dữ liệu. Cách chính xác để lưu trữ thông tin đó là trong một tuple hoặc trong một đối tượng. Hãy nói rằng chúng tôi có một vài:

[("Billy", "Bob", "Joe", 42), ("Robert", "", "Smith", 31)]

Tính bất biến và khả năng biến đổi của Tuples và Lists không phải là điểm khác biệt chính. Danh sách là danh sách các loại mặt hàng giống nhau: tệp, tên, đối tượng. Tuples là một nhóm các loại đối tượng khác nhau. Chúng có các cách sử dụng khác nhau và nhiều danh sách lạm dụng mã hóa Python cho các bộ dữ liệu có nghĩa là gì.

Xin đừng.

Biên tập:

Tôi nghĩ rằng bài đăng trên blog này giải thích lý do tại sao tôi nghĩ rằng điều này tốt hơn tôi đã làm: http://news.e-scribe.com/397

nếu tôi phải chuyển đổi một tuple thành một tập hợp hoặc danh sách để có thể sắp xếp chúng, thì điểm đầu tiên của việc sử dụng một tuple là gì?

Trong trường hợp cụ thể này, có lẽ không phải là một điểm. Đây không phải là vấn đề, vì đây không phải là một trong những trường hợp bạn cân nhắc sử dụng bộ dữ liệu.

Như bạn chỉ ra, tuples là bất biến. Những lý do để có các loại bất biến áp dụng cho bộ dữ liệu:

• sao chép hiệu quả: thay vì sao chép một đối tượng bất biến, bạn có thể đặt bí danh cho nó (liên kết một biến với một tham chiếu)
• hiệu quả so sánh: khi bạn đang sử dụng bản sao theo tham chiếu, bạn có thể so sánh hai biến bằng cách so sánh vị trí, thay vì nội dung
• thực tập: bạn cần lưu trữ tối đa một bản sao của bất kỳ giá trị bất biến nào
• không cần phải đồng bộ hóa quyền truy cập vào các đối tượng bất biến trong mã đồng thời
• const đúng: một số giá trị không được phép thay đổi. Điều này (với tôi) là lý do chính cho các loại bất biến.

Lưu ý rằng việc triển khai Python cụ thể có thể không sử dụng tất cả các tính năng trên.

Các khóa từ điển phải là bất biến, nếu không việc thay đổi các thuộc tính của đối tượng khóa có thể làm mất hiệu lực các bất biến của cấu trúc dữ liệu cơ bản. Tuples do đó có thể có khả năng được sử dụng như là chìa khóa. Đây là một hệ quả của sự đúng đắn const.

Xem thêm " Giới thiệu bộ dữ liệu ", từ Lặn vào Python .

Đôi khi chúng ta thích sử dụng các đối tượng làm khóa từ điển

Để biết giá trị của nó, bộ dữ liệu gần đây (2.6+) đã phát triển index()và count()phương pháp

Tôi luôn thấy có hai loại hoàn toàn riêng biệt cho cùng một cấu trúc dữ liệu cơ bản (mảng) là một thiết kế khó xử, nhưng không phải là vấn đề thực sự trong thực tế. (Mọi ngôn ngữ đều có mụn cóc, bao gồm Python, nhưng đây không phải là ngôn ngữ quan trọng.)

Tại sao mọi người quan tâm nếu một biến sống ở một nơi khác trong bộ nhớ so với khi nó được phân bổ ban đầu? Toàn bộ hoạt động kinh doanh bất biến trong Python này dường như được nhấn mạnh quá mức.

Đây là những điều khác nhau. Khả năng tương tác không liên quan đến nơi lưu trữ trong bộ nhớ; nó có nghĩa là những thứ nó chỉ ra không thể thay đổi.

Các đối tượng Python không thể thay đổi vị trí sau khi chúng được tạo, có thể thay đổi hoặc không. (Chính xác hơn, giá trị của id () không thể thay đổi - trong thực tế, điều tương tự.) Bộ lưu trữ bên trong của các đối tượng có thể thay đổi có thể thay đổi, nhưng đó là một chi tiết triển khai ẩn.

>>> x='hello'
>>> id(x)
1234567
>>> x='good bye'
>>> id(x)
5432167

Đây không phải là sửa đổi ("biến đổi") biến; nó tạo ra một biến mới có cùng tên và loại bỏ biến cũ. So sánh với một hoạt động đột biến:

>>> a = [1,2,3]
>>> id(a)
3084599212L
>>> a[1] = 5
>>> a
[1, 5, 3]
>>> id(a)
3084599212L

Như những người khác đã chỉ ra, điều này cho phép sử dụng các mảng làm chìa khóa cho từ điển và các cấu trúc dữ liệu khác cần sự bất biến.

Lưu ý rằng các khóa cho từ điển không phải là hoàn toàn bất biến. Chỉ một phần của nó được sử dụng như là một chìa khóa cần phải bất biến; Đối với một số sử dụng, đây là một sự khác biệt quan trọng. Ví dụ: bạn có thể có một lớp đại diện cho một người dùng, so sánh sự bình đẳng và hàm băm theo tên người dùng duy nhất. Sau đó, bạn có thể treo dữ liệu có thể thay đổi khác trên lớp - "người dùng đã đăng nhập", v.v. Vì điều này không ảnh hưởng đến sự bình đẳng hoặc hàm băm, nên có thể sử dụng nó làm khóa trong từ điển. Điều này không quá phổ biến trong Python; Tôi chỉ nêu ra vì một số người đã tuyên bố rằng các khóa cần phải là "bất biến", điều này chỉ đúng một phần. Mặc dù vậy, tôi đã sử dụng nhiều lần với các bản đồ và bộ C ++.

Như gnibbler đưa ra trong một bình luận, Guido có một ý kiến không được chấp nhận / đánh giá cao hoàn toàn: Các danh sách trên các dữ liệu đồng nhất, các bộ dữ liệu dành cho dữ liệu không đồng nhất. Tất nhiên, nhiều người trong số những người phản đối giải thích điều này có nghĩa là tất cả các yếu tố của một danh sách nên cùng loại.

Tôi thích nhìn thấy nó khác đi, không giống như những người khác cũng có trong quá khứ:

blue= 0, 0, 255
alist= ["red", "green", blue]

Lưu ý rằng tôi coi alist là đồng nhất, ngay cả khi loại (alist [1])! = Type (alist [2]).

Nếu tôi có thể thay đổi thứ tự của các phần tử và tôi sẽ không gặp vấn đề gì trong mã của mình (ngoài các giả định, ví dụ, thì nó nên được sắp xếp,), thì nên sử dụng một danh sách. Nếu không (như trong tuple blueở trên), thì tôi nên sử dụng một tuple.

Chúng rất quan trọng vì chúng đảm bảo cho người gọi rằng đối tượng mà chúng vượt qua sẽ không bị biến đổi. Nếu bạn làm điều này:

a = [1,1,1]
doWork(a)

Người gọi không đảm bảo giá trị của a sau cuộc gọi. Tuy nhiên,

a = (1,1,1)
doWorK(a)

Bây giờ bạn với tư cách là người gọi hoặc là người đọc mã này đều biết rằng a giống nhau. Bạn luôn có thể cho kịch bản này tạo một bản sao của danh sách và vượt qua điều đó nhưng bây giờ bạn đang lãng phí chu kỳ thay vì sử dụng một cấu trúc ngôn ngữ có ý nghĩa ngữ nghĩa hơn.

bạn có thể thấy ở đây để thảo luận về điều này

Câu hỏi của bạn (và nhận xét tiếp theo) tập trung vào việc id () thay đổi trong khi chuyển nhượng. Tập trung vào hiệu ứng tiếp theo này của sự khác biệt giữa thay thế đối tượng bất biến và sửa đổi đối tượng có thể thay đổi thay vì chính sự khác biệt có lẽ không phải là cách tiếp cận tốt nhất.

Trước khi chúng tôi tiếp tục, hãy đảm bảo rằng hành vi được thể hiện dưới đây là những gì bạn mong đợi từ Python.

>>> a1 = [1]
>>> a2 = a1
>>> print a2[0]
1
>>> a1[0] = 2
>>> print a2[0]
2

Trong trường hợp này, nội dung của a2 đã được thay đổi, mặc dù chỉ a1 có giá trị mới được gán. Tương phản với những điều sau đây:

>>> a1 = (1,)
>>> a2 = a1
>>> print a2[0]
1
>>> a1 = (2,)
>>> print a2[0]
1

Trong trường hợp sau này, chúng tôi đã thay thế toàn bộ danh sách, thay vì cập nhật nội dung của nó. Với các loại bất biến như bộ dữ liệu, đây là hành vi duy nhất được phép.

Vì sao vấn đề này? Giả sử bạn có một lệnh:

>>> t1 = (1,2)
>>> d1 = { t1 : 'three' }
>>> print d1
{(1,2): 'three'}
>>> t1[0] = 0  ## results in a TypeError, as tuples cannot be modified
>>> t1 = (2,3) ## creates a new tuple, does not modify the old one
>>> print d1   ## as seen here, the dict is still intact
{(1,2): 'three'}

Sử dụng một tuple, từ điển sẽ an toàn khi các khóa của nó được thay đổi "từ bên dưới" thành các mục băm thành một giá trị khác. Điều này là rất quan trọng để cho phép thực hiện hiệu quả.