Hàm băm từ điển Python

Hash Table vs Dictionary

In computer science, a dictionary is an abstract data type made up of keys and values arranged in pairs. Moreover, it defines the following operations for those elements

• Add a key-value pair
• Delete a key-value pair
• Update a key-value pair
• Find a value associated with the given key

In a sense, this abstract data type resembles a bilingual dictionary, where the keys are foreign words, and the values are their definitions or translations to other languages. But there doesn’t always have to be a sense of equivalence between keys and values. A phone book is another example of a dictionary, which combines names with the corresponding phone numbers

Note. Anytime you map one thing to another or associate a value with a key, you’re essentially using a kind of a dictionary. That’s why dictionaries are also known as maps or associative arrays

Dictionaries have a few interesting properties. Một trong số đó là bạn có thể coi từ điển như một hàm toán học dự đoán một hoặc nhiều đối số cho chính xác một giá trị. The direct consequences of that fact are the following

• Only Key-Value Pairs. You can’t have a key without the value or the other way around in a dictionary. They always go together
• Arbitrary Keys and Values. Keys and values can belong to two disjoint sets of the same or separate types. Both keys and values may be almost anything, such as numbers, words, or even pictures
• Unordered Key-Value Pairs. Do điểm cuối cùng, từ điển thường không xác định bất kỳ thứ tự nào cho các cặp khóa-giá trị của chúng. Tuy nhiên, đó có thể là triển khai cụ thể
• Phím duy nhất. Từ điển không được chứa các khóa trùng lặp, vì điều đó sẽ vi phạm định nghĩa của hàm
• Giá trị không duy nhất. Có thể liên kết cùng một giá trị với nhiều khóa nhưng không nhất thiết phải

Có những khái niệm liên quan mở rộng ý tưởng về từ điển. Ví dụ: nhiều ánh xạ cho phép bạn có nhiều giá trị cho mỗi khóa, trong khi ánh xạ hai chiều không chỉ ánh xạ các khóa tới các giá trị mà còn cung cấp ánh xạ theo hướng ngược lại. Tuy nhiên, trong hướng dẫn này, bạn sẽ chỉ xem xét từ điển thông thường, từ điển này ánh xạ chính xác một giá trị cho mỗi khóa

Đây là một mô tả đồ họa của một từ điển giả định, ánh xạ một số khái niệm trừu tượng với các từ tiếng Anh tương ứng của chúng

Đó là bản đồ một chiều của khóa tới giá trị, là hai bộ phần tử hoàn toàn khác nhau. Ngay lập tức, bạn có thể thấy ít giá trị hơn khóa vì từ cung là một từ đồng âm với nhiều nghĩa. Về mặt khái niệm, từ điển này vẫn chứa bốn cặp, mặc dù. Tùy thuộc vào cách bạn quyết định triển khai nó, bạn có thể sử dụng lại các giá trị lặp lại để tiết kiệm bộ nhớ hoặc sao chép chúng để đơn giản

Bây giờ, làm thế nào để bạn mã hóa một từ điển như vậy bằng ngôn ngữ lập trình? . Python vận chuyển với loại

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> glossary = {"BDFL": "Benevolent Dictator For Life"}
>>> glossary["GIL"] = "Global Interpreter Lock"  # Add
>>> glossary["BDFL"] = "Guido van Rossum"  # Update
>>> del glossary["GIL"]  # Delete
>>> glossary["BDFL"]  # Search
'Guido van Rossum'
>>> glossary
{'BDFL': 'Guido van Rossum'}

Với cú pháp ngoặc vuông [

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Điều đó nói rằng, bạn có thể hỏi một câu hỏi khác. Từ điển tích hợp thực sự hoạt động như thế nào?

Tìm cách triển khai hiệu quả loại dữ liệu trừu tượng này được gọi là vấn đề từ điển. One of the most well-known solutions takes advantage of the hash table data structure that you’re about to explore. However, note that it isn’t the only way to implement a dictionary in general. Another popular implementation builds on top of a red-black tree

Hash Table. An Array With a Hash Function

Have you ever wondered why accessing sequence elements in Python works so quickly, regardless of which index you request? Say you were working with a very long string of characters, like this one

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

There are 2. 6 billion characters from repeating ASCII letters in the

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

The same is true for all sequence types in Python, such as lists and tuples. How come? The secret to such a blazing speed is that sequences in Python are backed by an array, which is a random-access data structure. It follows two principles

1. The array occupies a contiguous block of memory
2. Every element in the array has a fixed size known up front

When you know the memory address of an array, which is called the offset, then you can get to the desired element in the array instantly by calculating a fairly straightforward formula

You start at the array’s offset, which is also the address of the array’s first element, with the index zero. Next, you move forward by adding the required number of bytes, which you get by multiplying the element size by the target element’s index. It always takes the same amount of time to multiply and add a few numbers together

Note. Unlike arrays, Python’s lists can contain heterogeneous elements of varying sizes, which would break the above formula. To mitigate this, Python adds another level of indirection by introducing an array of pointers to memory locations rather than storing values directly in the array

Pointers are merely integer numbers, which always take up the same amount of space. It’s customary to denote memory addresses using the hexadecimal notation. Python and some other languages prefix such numbers with

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Okay, so you know that finding an element in an array is quick, no matter where that element is physically located. Can you take the same idea and reuse it in a dictionary? Yes

Hash tables get their name from a trick called hashing, which lets them translate an arbitrary key into an integer number that can work as an index in a regular array. So, instead of searching a value by a numeric index, you’ll look it up by an arbitrary key without a noticeable performance loss. That’s neat

In practice, hashing won’t work with every key, but most built-in types in Python can be hashed. If you follow a few rules, then you’ll be able to create your own hashable types too. You’ll learn more about hashing in the next section

Kiểm tra

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

68 tích hợp sẵn của Python

Before taking a stab at implementing a hash function from scratch, hold on for a moment and analyze Python’s

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Ghi chú. Việc lựa chọn hàm băm có thể ảnh hưởng đáng kể đến hiệu suất của bảng băm của bạn. Do đó, bạn sẽ dựa vào hàm

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Đối với người mới bắt đầu, hãy thử gọi

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

There are already several observations that you can make by looking at the result. First, the built-in hash function may return different values on your end for some of the inputs shown above. While the numeric input always seems to produce an identical hash value, the string most likely doesn’t. Why is that? It may seem like

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

When you call

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

That’s because hash values are immutable and don’t change throughout an object’s lifetime. However, as soon as you exit Python and start it again, then you’ll almost certainly see different hash values across Python invocations. You can test this by trying the

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

• các cửa sổ
• Linux + macOS

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

That’s expected behavior, which was implemented in Python as a countermeasure against a Denial-of-Service [DoS] attack that exploited a known vulnerability of hash functions in web servers. Attackers could abuse a weak hash algorithm to deliberately create so-called hash collisions, overloading the server and making it inaccessible. Ransom was a typical motive for the attack as most victims made money through an uninterrupted online presence

Today, Python enables hash randomization by default for some inputs, such as strings, to make the hash values less predictable. This makes

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

• các cửa sổ
• Linux + macOS

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Now, each Python invocation yields the same hash value for a known input. This can help in partitioning or sharing data across a cluster of distributed Python interpreters. Chỉ cần cẩn thận và hiểu những rủi ro liên quan đến việc vô hiệu hóa băm ngẫu nhiên. Nói chung,

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Ngoài ra,

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Here, you called the hash function on Python’s

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Loại cơ bản của đầu vào sẽ xác định xem bạn có thể tính giá trị băm hay không. Trong Python, các phiên bản của các loại có thể thay đổi được tích hợp sẵn—như danh sách, bộ và ký tự—không thể băm được. Bạn đã có một gợi ý về lý do tại sao lại như vậy, nhưng bạn sẽ tìm hiểu thêm trong phần sau. Hiện tại, bạn có thể cho rằng hầu hết các loại dữ liệu sẽ hoạt động với hàm băm nói chung

Tìm hiểu sâu hơn về

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

68 của Python

Một đặc điểm thú vị khác của

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

The natural consequence of a fixed-size output is that most of the original information gets irreversibly lost during the process. Rốt cuộc, điều đó tốt vì bạn muốn giá trị băm kết quả hoạt động như một bản tóm tắt thống nhất của dữ liệu lớn tùy ý. However, because the hash function projects a potentially infinite set of values onto a finite space, this can lead to a hash collision when two different inputs produce the same hash value

Note. Nếu bạn thiên về toán học, thì bạn có thể sử dụng nguyên tắc chuồng bồ câu để mô tả các xung đột hàm băm một cách chính thức hơn

Given m items and n containers, if m > n, then there’s at least one container with more than one item

Trong bối cảnh này, các mục là một số lượng giá trị có khả năng vô hạn mà bạn nạp vào hàm băm, trong khi các vùng chứa là các giá trị băm của chúng được chỉ định từ một nhóm hữu hạn

Hash collisions are an essential concept in hash tables, which you’ll revisit later in more depth when implementing your custom hash table. For now, you can think of them as highly undesirable. Bạn nên tránh xung đột băm càng nhiều càng tốt vì chúng có thể dẫn đến việc tra cứu rất kém hiệu quả và có thể bị tin tặc khai thác. Therefore, a good hash function must minimize the likelihood of a hash collision for both security and efficiency

Trong thực tế, điều này thường có nghĩa là hàm băm phải gán các giá trị được phân phối đồng đều trên không gian có sẵn. You can visualize the distribution of hash values produced by Python’s

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Nó sử dụng một phiên bản

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Khi chỉ có hai vùng chứa, bạn sẽ mong đợi phân phối khoảng 50-50. Việc thêm nhiều thùng chứa sẽ dẫn đến việc lấp đầy chúng nhiều hơn hoặc ít hơn. Như bạn có thể thấy, hàm

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Related to that, the uniform distribution of hash values is typically pseudo-random, which is especially important for cryptographic hash functions. Điều này ngăn những kẻ tấn công tiềm năng sử dụng phân tích thống kê để thử và dự đoán mối tương quan giữa đầu vào và đầu ra của hàm băm. Cân nhắc việc thay đổi một chữ cái trong chuỗi và kiểm tra xem điều đó ảnh hưởng như thế nào đến giá trị băm thu được trong Python

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

It’s a completely different hash value now, despite only one letter being different. Hash values are often subject to an avalanche effect, as even the smallest input change gets amplified. Nevertheless, this feature of the hash function isn’t essential for the sake of implementing a hash table data structure

In most cases, Python’s

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Hash values of small integers are equal to themselves, which is an implementation detail that CPython uses for simplicity and efficiency. Bear in mind that the actual hash values don’t matter as long as you can calculate them in a deterministic way

Last but not least, calculating a hash value in Python is fast, even for very big inputs. On a modern computer, calling

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Identify Hash Function Properties

Based on what you’ve learned so far about Python’s

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

FeatureHash FunctionCryptographic Hash FunctionDeterministic✔️✔️Universal Input✔️✔️Fixed-Sized Output✔️✔️Fast to Compute✔️✔️Uniformly Distributed✔️✔️Randomly Distributed✔️Randomized Seed✔️One-Way Function✔️Avalanche Effect✔️

The goals of both hash function types overlap, so they share a few common features. On the other hand, a cryptographic hash function provides additional guarantees around security

Before building your own hash function, you’ll take a look at another function built into Python that’s seemingly its most straightforward substitute

Compare an Object’s Identity With Its Hash

Probably one of the most straightforward hash function implementations imaginable in Python is the built-in

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

The

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

So, why does Python insist on using a different function for hashing then?

First of all, the intent of

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Note. Later, you’ll learn more about the contract between the equality of values and the corresponding hash codes

With that out of the way, you can finally think of making your own hash function

Make Your Own Hash Function

Designing a hash function that meets all requirements from scratch is hard. As mentioned before, you’ll be using the built-in

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

In this exercise, you can limit yourself to only one data type at first and implement a crude hash function around it. For example, you could consider strings and sum up the ordinal values of the individual characters in them

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

You iterate over the text using a generator expression, then turn each individual character into the corresponding Unicode code point with the built-in

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Right away, you’ll notice a few problems with this function. Not only is it string-specific, but it also suffers from poor distribution of hash codes, which tend to form clusters at similar input values. Một thay đổi nhỏ trong đầu vào ít ảnh hưởng đến đầu ra quan sát được. Even worse, the function remains insensitive to character order in the text, which means anagrams of the same word, such as Loren and Loner, lead to a hash code collision

To fix the first problem, try converting the input to a string with a call to

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

You can call

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Note that this implementation will only be as good as the corresponding string representation. Some objects may not have a textual representation suitable for the code above. In particular, custom class instances without the special methods

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

In reality, you’d want to treat the string

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

That’ll improve your hash function to some extent

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Strings are now distinguishable from numbers. To tackle the issue with anagrams, like Loren and Loner, you might modify your hash function by taking into consideration the character’s value as well as its position within the text

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Tại đây, bạn lấy tổng các tích có được từ việc nhân các giá trị thứ tự của các ký tự và chỉ số tương ứng của chúng. Notice you enumerate the indices from one rather than zero. Otherwise, the first character would always be discarded as its value would be multiplied by zero

Bây giờ, hàm băm của bạn khá phổ biến và không gây ra nhiều va chạm như trước, nhưng đầu ra của nó có thể lớn tùy ý vì chuỗi càng dài, mã băm càng lớn. Ngoài ra, nó khá chậm đối với đầu vào lớn hơn

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Bạn luôn có thể giải quyết vấn đề tăng trưởng không giới hạn bằng cách lấy modulo [

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Hãy nhớ rằng việc chọn nhóm mã băm nhỏ hơn sẽ làm tăng khả năng xảy ra xung đột mã băm. If you don’t know the number of your input values up front, then it’s best to leave that decision until later if you can. Bạn cũng có thể áp đặt giới hạn cho mã băm của mình bằng cách giả định một giá trị tối đa hợp lý, chẳng hạn như

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Bỏ qua tốc độ chậm của hàm trong giây lát, bạn sẽ nhận thấy một vấn đề đặc biệt khác với hàm băm của mình. Nó dẫn đến việc phân phối mã băm dưới mức tối ưu thông qua phân cụm và do không tận dụng được tất cả các vị trí có sẵn

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Sự phân bố không đồng đều. Hơn nữa, có sẵn sáu vùng chứa, nhưng một vùng bị thiếu trong biểu đồ. Vấn đề này bắt nguồn từ thực tế là hai dấu nháy đơn được thêm vào bởi

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Cuộc gọi đến

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Naturally, you can continue improving your hash function further. If you’re curious about the implementation of

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>>

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Tại thời điểm này, bạn đã nắm khá rõ về hàm băm, cách thức hoạt động của nó và những thách thức bạn có thể gặp phải khi triển khai nó. In the upcoming sections, you’ll use a hash function to build a hash table. Việc lựa chọn một thuật toán băm cụ thể sẽ ảnh hưởng đến hiệu suất của bảng băm. Với kiến ​​thức đó làm nền tảng, bạn có thể thoải mái gắn bó với

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Tham gia một khóa học cấp tốc về phát triển dựa trên thử nghiệm

Bây giờ bạn đã biết các thuộc tính cấp cao của hàm băm và mục đích của nó, bạn có thể thực hiện phương pháp phát triển dựa trên thử nghiệm để xây dựng bảng băm. Nếu bạn chưa bao giờ thử kỹ thuật lập trình này trước đây, thì nó sẽ tóm tắt thành ba bước mà bạn có xu hướng lặp lại theo chu kỳ

1. 🟥 Đỏ. Hãy nghĩ về một trường hợp thử nghiệm duy nhất và tự động hóa nó bằng cách sử dụng khung thử nghiệm đơn vị do bạn chọn. Your test will fail at this point, but that’s okay. Người chạy thử nghiệm thường biểu thị một thử nghiệm không đạt bằng màu đỏ, do đó có tên của giai đoạn chu kỳ này
2. 🟩 Green. Implement the bare minimum to make your test pass, but no more. This will ensure higher code coverage and spare you from writing redundant code. Báo cáo thử nghiệm sẽ sáng lên với màu xanh lá cây ưng ý sau đó
3. ♻️ Tái cấu trúc. Tùy chọn, sửa đổi mã của bạn mà không thay đổi hành vi của nó miễn là tất cả các trường hợp thử nghiệm vẫn vượt qua. You can use this as an opportunity to remove duplication and improve the readability of your code

Python comes with the unittest package out of the box, but the third-party pytest library has an arguably shallower learning curve, so you’ll use that in this tutorial instead. Go ahead and install

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

• các cửa sổ
• Linux + macOS

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Remember that you can verify each implementation stage against several control checkpoints. Next, create a file named

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

The framework leverages the built-in

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

The

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Now, open the terminal, change your working directory to wherever you saved that test file, and run the

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

• các cửa sổ
• Linux + macOS

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Uh-oh. There’s a failure in your test. To find the root cause, increase the verbosity of pytest’s output by appending the

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Đầu ra hiển thị giá trị thực tế và dự kiến ​​cho xác nhận không thành công. In this case, adding two plus two results in four rather than twenty-two. Bạn có thể sửa mã bằng cách sửa giá trị dự kiến

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Khi bạn chạy lại pytest, sẽ không còn test fail nữa

• các cửa sổ
• Linux + macOS

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Đó là nó. Bạn vừa học các bước thiết yếu trong việc tự động hóa các trường hợp thử nghiệm để triển khai bảng băm của mình. Đương nhiên, bạn có thể sử dụng một IDE chẳng hạn như PyCharm hoặc trình chỉnh sửa như VS Code tích hợp với các khung thử nghiệm nếu điều đó thuận tiện hơn cho bạn. Tiếp theo, bạn sẽ áp dụng kiến ​​thức mới này vào thực tế

Xác định một lớp

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

31 tùy chỉnh

Hãy nhớ tuân theo chu trình tái cấu trúc đỏ-xanh lá cây được mô tả trước đó. Therefore, you must start by identifying your first test case. Ví dụ: bạn sẽ có thể khởi tạo một bảng băm mới bằng cách gọi lớp

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Tại thời điểm này, bài kiểm tra của bạn sẽ từ chối chạy do có câu lệnh nhập không đạt yêu cầu ở đầu tệp. You’re in the red phase, after all. Giai đoạn màu đỏ là thời điểm duy nhất bạn được phép thêm các tính năng mới, vì vậy hãy tiếp tục và tạo một mô-đun khác có tên là

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Đó là một trình giữ chỗ lớp cơ bản, nhưng nó chỉ đủ để vượt qua bài kiểm tra của bạn. Nhân tiện, nếu bạn đang sử dụng trình chỉnh sửa mã, thì bạn có thể chia chế độ xem thành các cột một cách thuận tiện, hiển thị mã đang được kiểm tra và các bài kiểm tra tương ứng cạnh nhau

Nếu bạn tò mò về bảng màu được mô tả trong ảnh chụp màn hình ở trên, thì đó là Chủ đề Dracula. It’s available for many code editors and not just PyCharm

Once running pytest succeeds, then you can start thinking of another test case since there’s barely anything to refactor yet. Ví dụ: một bảng băm cơ bản phải chứa một chuỗi các giá trị. Ở giai đoạn đầu này, bạn có thể giả định rằng chuỗi có kích thước cố định được thiết lập tại thời điểm tạo bảng băm. Modify your existing test case accordingly

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

You specify the size using a keyword argument. However, before adding new code to the

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

After confirming that you’re in the red phase, declare the

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

bùng nổ. Bạn đang quay lại giai đoạn xanh một lần nữa, vậy lần này tái cấu trúc một chút thì sao? . Đừng quên thay đổi trường hợp kiểm tra trước, sau đó chạy pytest và luôn cập nhật mã đang kiểm tra ở bước cuối cùng

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Như bạn có thể thấy, chu trình tái cấu trúc đỏ-xanh lục bao gồm các giai đoạn ngắn, thường kéo dài không quá vài giây mỗi giai đoạn. Vì vậy, tại sao bạn không tiếp tục bằng cách thêm nhiều trường hợp thử nghiệm hơn? . Thêm một trường hợp thử nghiệm khác và quan sát xem nó thất bại thảm hại như thế nào

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

To handle

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn có thể nghĩ rằng TDD không đưa bạn đi đúng hướng. That’s not how you might have envisioned the hash table implementation. Đâu là chuỗi các giá trị mà bạn đã bắt đầu từ đầu? . Do đó, nó có thể không phù hợp với các dự án liên quan đến nhiều thử nghiệm

On the other hand, implementing a well-known data structure such as a hash table is a perfect application of this software development methodology. Bạn có những kỳ vọng rõ ràng, dễ dàng mã hóa thành các trường hợp thử nghiệm. Chẳng mấy chốc, bạn sẽ tự mình thấy rằng việc thực hiện bước tiếp theo sẽ dẫn đến một thay đổi nhỏ trong quá trình triển khai. Tuy nhiên, đừng lo lắng về điều đó, vì bản thân việc hoàn thiện mã không quan trọng bằng việc vượt qua các ca kiểm thử của bạn.

As you keep adding more constraints through the test cases, you frequently have to rethink your implementation. Ví dụ: một bảng băm mới có thể bắt đầu với các vị trí trống cho các giá trị được lưu trữ

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Nói cách khác, một bảng băm mới sẽ hiển thị thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Ghi chú. Theo nguyên tắc chung, các trường hợp thử nghiệm của bạn phải độc lập và nguyên tử nhất có thể, điều này thường có nghĩa là chỉ sử dụng một xác nhận cho mỗi chức năng. Tuy nhiên, các kịch bản thử nghiệm của bạn đôi khi có thể cần một chút thiết lập hoặc phân tích. They may also involve a few steps. Trong những trường hợp như vậy, theo thông lệ, bạn sẽ cấu trúc chức năng của mình xung quanh cái gọi là quy ước đã cho-khi-thì

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Phần đã cho mô tả trạng thái ban đầu và các điều kiện tiên quyết cho trường hợp thử nghiệm của bạn, trong khi when đại diện cho hành động của mã của bạn đang được thử nghiệm và sau đó chịu trách nhiệm khẳng định kết quả thu được

Đây là một trong nhiều cách khả thi để đáp ứng các bài kiểm tra hiện tại của bạn

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn thay thế thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Note. A Python dictionary has a length corresponding to the actual number of key-value pairs stored instead of its internal capacity. You’ll achieve a similar effect soon

Now that you’re acquainted with TDD, it’s time to dive deeper and add the remaining features to your hash table

Chèn một cặp khóa-giá trị

Bây giờ bạn có thể tạo một bảng băm, đã đến lúc cung cấp cho nó một số khả năng lưu trữ. The traditional hash table is backed by an array capable of storing only one data type. Do đó, việc triển khai bảng băm trong nhiều ngôn ngữ, chẳng hạn như Java, yêu cầu bạn phải khai báo loại cho các khóa và giá trị của chúng trước

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

This particular hash table maps strings to integers, for example. Tuy nhiên, vì mảng không có nguồn gốc từ Python nên bạn sẽ tiếp tục sử dụng danh sách để thay thế. As a side effect, your hash table will be able to accept arbitrary data types for both the keys and values, just like Python’s

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Note. Python có một bộ sưu tập

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Now add another test case for inserting key-value pairs into your hash table using the familiar square bracket syntax

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Đầu tiên, bạn tạo một bảng băm với một trăm vị trí trống, sau đó điền vào đó ba cặp khóa và giá trị thuộc nhiều loại khác nhau, bao gồm chuỗi, số dấu phẩy động và Booleans. Finally, you assert that the hash table contains the expected values in whatever order. Note that your hash table only remembers the values but not the associated keys at the moment

The most straightforward and perhaps slightly naive implementation that would satisfy this test is as follows

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

It completely ignores the key and just appends the value to the right end of the list, increasing its length. Bạn rất có thể nghĩ ngay đến một trường hợp thử nghiệm khác. Inserting elements into the hash table shouldn’t grow its size. Tương tự như vậy, việc xóa một phần tử không nên thu nhỏ bảng băm, nhưng bạn chỉ cần ghi nhớ điều đó trong đầu vì chưa có khả năng xóa các cặp khóa-giá trị

Ghi chú. Bạn cũng có thể viết một bài kiểm tra trình giữ chỗ và yêu cầu pytest bỏ qua nó vô điều kiện cho đến sau này

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

It leverages one of the decorators provided by pytest

In the real world, you’d want to create separate test cases with descriptive names dedicated to testing these behaviors. Tuy nhiên, vì đây chỉ là hướng dẫn nên bạn sẽ thêm một xác nhận mới vào chức năng hiện có cho ngắn gọn

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bây giờ bạn đang ở giai đoạn màu đỏ, vì vậy hãy viết lại phương thức đặc biệt của bạn để luôn cố định dung lượng

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn biến một khóa tùy ý thành giá trị băm số và sử dụng toán tử modulo để hạn chế chỉ mục kết quả trong không gian địa chỉ có sẵn. Tuyệt quá. Báo cáo thử nghiệm của bạn lại sáng lên màu xanh lá cây

Ghi chú. Đoạn mã trên dựa vào hàm

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

• các cửa sổ
• Linux + macOS

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Đảm bảo chọn hạt giống băm không gây ra bất kỳ xung đột nào trong dữ liệu mẫu của bạn. Tìm một cái có thể liên quan đến một chút thử và sai. Trong trường hợp của tôi, giá trị

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Nhưng bạn có thể nghĩ ra một số trường hợp cạnh không? . Bạn sẽ muốn tránh điều đó

As always, start by writing a test case to express the desired behavior

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

One way to work around this would be to replace

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn chỉ cần một phiên bản trống duy nhất để đánh dấu các vị trí là trống. Naturally, you’ll need to update an older test case to get back to the green phase

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Then, write a positive test case exercising the happy path for handling the insertion of a

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

You create an empty hash table with one hundred slots and insert

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Source Code. Click here to download the source code that you’ll use to build a hash table in Python

In the next subsection, you’ll add the ability to retrieve values by their associated keys

Tìm giá trị theo khóa

Để truy xuất một giá trị từ bảng băm, bạn sẽ muốn tận dụng cú pháp dấu ngoặc vuông giống như trước đây, chỉ khi không sử dụng câu lệnh gán. Bạn cũng sẽ cần một bảng băm mẫu. Để tránh sao chép mã thiết lập giống nhau trên các trường hợp thử nghiệm riêng lẻ trong bộ thử nghiệm của bạn, bạn có thể bọc nó trong một bộ cố định thử nghiệm do pytest đưa ra

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

A test fixture is a function annotated with the

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

To be able to find values by key, you can implement the element lookup through another special method called

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

You calculate the index of an element based on the hash code of the provided key and return whatever sits under that index. Nhưng còn thiếu chìa khóa thì sao? . To replicate how a Python

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn tạo một bảng băm trống và thử truy cập một trong các giá trị của nó thông qua một khóa bị thiếu. Khung pytest bao gồm một cấu trúc đặc biệt để kiểm tra các ngoại lệ. Ở trên, bạn sử dụng trình quản lý ngữ cảnh

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

If the value at the given index is blank, then you raise the exception. Nhân tiện, bạn sử dụng toán tử

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Because you can now determine whether a given key has an associated value in your hash table, you might as well implement the

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Cả hai trường hợp thử nghiệm đều tận dụng vật cố định thử nghiệm mà bạn đã chuẩn bị trước đó và xác minh phương pháp đặc biệt

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Khi truy cập vào khóa đã cho sẽ tạo ra một

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Mã của

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

You attempt to return the value corresponding to the provided key. Trong trường hợp có ngoại lệ, bạn trả về giá trị mặc định, là đối số tùy chọn. Khi người dùng để nó không xác định, thì nó bằng

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

For completeness, you’ll add the capability to delete a key-value pair from your hash table in the upcoming subsection

Xóa cặp khóa-giá trị

Từ điển Python cho phép bạn xóa các cặp khóa-giá trị đã chèn trước đó bằng cách sử dụng từ khóa

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Trước tiên, bạn xác minh xem bảng băm mẫu có khóa và giá trị mong muốn hay không. Sau đó, bạn xóa cả hai bằng cách chỉ cho biết khóa và lặp lại các xác nhận nhưng với kỳ vọng đảo ngược. Bạn có thể vượt qua bài kiểm tra này như sau

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn tính toán chỉ mục được liên kết với một khóa và xóa giá trị tương ứng khỏi danh sách một cách vô điều kiện. Tuy nhiên, bạn ngay lập tức nhớ lại ghi chú trong đầu trước đó về việc khẳng định rằng bảng băm của bạn sẽ không co lại khi bạn xóa các phần tử khỏi nó. Vì vậy, bạn thêm hai khẳng định nữa

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

These will ensure that the size of your hash table’s underlying list remains unaffected. Bây giờ, bạn cần cập nhật mã của mình để nó đánh dấu một vị trí trống thay vì vứt bỏ hoàn toàn

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Xét rằng bạn đang ở giai đoạn xanh một lần nữa, bạn có thể tận dụng cơ hội này để dành thời gian tái cấu trúc. Cùng một công thức lập chỉ mục xuất hiện ba lần ở những nơi khác nhau. Bạn có thể giải nén nó và đơn giản hóa mã

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Suddenly, after applying only this slight modification, a pattern emerges. Xóa một mục tương đương với việc chèn một đối tượng trống. So, you can rewrite your deletion routine to take advantage of the mutator method

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Gán một giá trị thông qua cú pháp dấu ngoặc vuông ủy quyền cho phương thức

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bao gồm trường hợp thử nghiệm này tương đối đơn giản vì bạn có thể dựa vào mã mà bạn đã viết khi triển khai toán tử

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Nếu bạn tìm thấy khóa trong bảng băm của mình, thì bạn sẽ ghi đè giá trị được liên kết bằng giá trị trọng điểm để xóa cặp đó. Otherwise, you raise an exception. All right, there’s one more basic hash table operation to cover, which you’ll do next

Cập nhật giá trị của một cặp hiện có

Phương thức chèn đã đảm nhiệm việc cập nhật cặp khóa-giá trị, vì vậy, bạn sẽ chỉ thêm một trường hợp thử nghiệm có liên quan và kiểm tra xem nó có hoạt động như mong đợi không

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Sau khi sửa đổi giá trị, xin chào, của một khóa hiện có và thay đổi nó thành hallo, bạn cũng kiểm tra xem các cặp khóa-giá trị khác, cũng như độ dài của bảng băm, có còn nguyên không. Đó là nó. You already have a basic hash table implementation, but a few extra features that are relatively cheap to implement are still missing

Nhận các cặp khóa-giá trị

Đã đến lúc nói chuyện với con voi trong phòng. Từ điển Python cho phép bạn lặp lại các khóa, giá trị hoặc cặp khóa-giá trị được gọi là mục. Tuy nhiên, bảng băm của bạn thực sự chỉ là một danh sách các giá trị được lập chỉ mục ưa thích ở trên cùng. Nếu bạn từng muốn truy xuất các khóa ban đầu được đưa vào bảng băm của mình, thì bạn sẽ không gặp may vì việc triển khai bảng băm hiện tại sẽ không bao giờ nhớ chúng

Trong tiểu mục này, bạn sẽ cấu trúc lại bảng băm của mình rất nhiều để thêm khả năng giữ lại các khóa và giá trị. Hãy nhớ rằng sẽ có một số bước liên quan và nhiều thử nghiệm sẽ bắt đầu thất bại do đó. If you’d like to skip those intermediate steps and see the effect, then jump ahead to defensive copying

Đợi tí. Bạn tiếp tục đọc về các cặp khóa-giá trị trong hướng dẫn này, vậy tại sao không thay thế các giá trị bằng các bộ? . Thậm chí tốt hơn, bạn có thể sử dụng các bộ dữ liệu được đặt tên để tận dụng lợi thế của việc tra cứu phần tử được đặt tên của chúng. Nhưng trước tiên, bạn cần nghĩ ra một bài kiểm tra

Ghi chú. Hãy nhớ tập trung vào chức năng hướng tới người dùng cấp cao khi tìm ra trường hợp thử nghiệm. Đừng tiến hành kiểm tra một đoạn mã mà bạn có thể dự đoán dựa trên kinh nghiệm hoặc cảm tính của lập trình viên của bạn. It’s the tests that should ultimately drive your implementation in TDD, not the other way around

First of all, you’re going to need another attribute in your

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

The order of key-value pairs is unimportant at this point, so you can assume that they might come out in any order each time you request them. However, instead of introducing another field to the class, you could reuse

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Ghi chú. Nếu bạn đang sử dụng trình chỉnh sửa mã, thì bạn có thể đổi tên biến hoặc thành viên lớp một cách thuận tiện chỉ bằng một lần bấm nút bằng cách tận dụng khả năng tái cấu trúc. In PyCharm, for example, you can right-click on a variable, choose Refactor from the context menu, and then Rename…. Or you can use the corresponding keyboard shortcut

That’s the most straightforward and reliable way of changing the name of a variable in your project. Trình chỉnh sửa mã sẽ cập nhật tất cả các tham chiếu biến trên các tệp dự án của bạn

Khi bạn đã đổi tên

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Chèn một phần tử vào bảng băm của bạn bao bọc khóa và giá trị trong một bộ rồi đặt bộ đó vào chỉ mục mong muốn trong danh sách các cặp của bạn. Lưu ý rằng danh sách của bạn ban đầu sẽ chỉ chứa các đối tượng trống thay vì các bộ dữ liệu, do đó, bạn sẽ sử dụng hai loại dữ liệu khác nhau trong danh sách các cặp của mình. One is a tuple, while the other one could be anything but a tuple to denote a blank slot

Do đó, bạn không cần bất kỳ hằng số canh gác đặc biệt nào nữa để đánh dấu một vị trí trống. Bạn có thể xóa hằng số

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Ghi chú. Việc xóa mã có thể khó chấp nhận lúc đầu, nhưng càng ít càng tốt. As you can see, test-driven development can sometimes make you run in circles

Bạn có thể lùi lại một bước để giành lại quyền kiểm soát việc xóa một mục

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Thật không may, phương pháp

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Phần quan trọng cuối cùng của câu đố là cập nhật phương thức

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn xem nhanh một chỉ mục, hy vọng tìm thấy một cặp khóa-giá trị. Nếu bạn không nhận được gì cả, thì bạn đưa ra một ngoại lệ. On the other hand, if you see something interesting, then you grab the tuple’s second element at index one, which corresponds to the mapped value. Tuy nhiên, bạn có thể viết điều này một cách tao nhã hơn bằng cách sử dụng một bộ dữ liệu có tên, như đã đề xuất trước đó

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Lớp

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Ghi chú. Mặc dù sử dụng loại dữ liệu tùy chỉnh để biểu thị các cặp khóa-giá trị, bạn có thể viết các bài kiểm tra của mình để mong đợi các phiên bản

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Đương nhiên, bạn có một số trường hợp thử nghiệm cần cập nhật vào thời điểm này trước khi báo cáo có thể chuyển sang màu xanh trở lại. Dành thời gian của bạn và xem xét cẩn thận bộ thử nghiệm của bạn. Ngoài ra, hãy xem mã từ các tài liệu hỗ trợ nếu bạn cảm thấy bế tắc hoặc xem qua tại đây

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

There will be another test case that needs special care. Specifically, it’s about verifying that an empty hash table has no

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Nếu bạn lo lắng về việc nhét quá nhiều logic vào trường hợp thử nghiệm, thì bạn hoàn toàn đúng. Rốt cuộc, bạn muốn kiểm tra hành vi của bảng băm. Nhưng đừng lo lắng về điều đó. Bạn sẽ sớm xem lại trường hợp thử nghiệm này

Sử dụng sao chép phòng thủ

Khi bạn đã trở lại giai đoạn xanh, hãy cố gắng tìm ra các trường hợp phạt góc có thể xảy ra. Ví dụ:

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bất cứ khi nào bạn yêu cầu các cặp khóa-giá trị từ bảng băm, bạn sẽ nhận được một đối tượng hoàn toàn mới với một danh tính duy nhất. You can hide a private field behind a Python property, so create one and replace every reference to

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

When you request a list of key-value pairs stored in your hash table, you’ll get their shallow copy each time. Vì bạn sẽ không có tham chiếu đến trạng thái bên trong của bảng băm, nên nó sẽ không bị ảnh hưởng bởi những thay đổi tiềm ẩn đối với bản sao của nó

Ghi chú. Thứ tự của các phương thức lớp mà bạn đến có thể hơi khác so với thứ tự trong khối mã được trình bày ở trên. Điều đó không sao vì thứ tự phương thức không quan trọng theo quan điểm của Python. Tuy nhiên, theo thông lệ, bạn nên bắt đầu với các phương thức lớp hoặc tĩnh, tiếp theo là giao diện chung của lớp mà bạn có nhiều khả năng xem xét nhất. The internal implementation should typically appear at the very end

Để tránh phải nhảy xung quanh mã của bạn, bạn nên tổ chức các phương thức theo cách giống như một câu chuyện. Specifically, a higher-level function should be listed before the low-level functions that are called

Để bắt chước hơn nữa

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Để đáp ứng thử nghiệm này, bạn có thể lọc các giá trị trống bằng cách thêm một điều kiện vào phần hiểu danh sách trong thuộc tính của mình

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn không cần gọi rõ ràng tới

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

That’s not ideal because one of your tests reaches out for the internal implementation instead of focusing on public interfaces. Tuy nhiên, thử nghiệm như vậy được gọi là thử nghiệm hộp trắng, có vị trí của nó

Lấy khóa và giá trị

Bạn có nhớ trường hợp thử nghiệm mà bạn đã sửa đổi bằng cách thêm khả năng hiểu danh sách để truy xuất các giá trị từ các cặp khóa-giá trị của mình không?

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Dòng được đánh dấu trông giống như những gì bạn cần để triển khai thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Nó có thể cảm thấy như thể đó là một nỗ lực lãng phí. Tuy nhiên, các giá trị này hiện được đánh giá động thông qua thuộc tính getter, trong khi trước đây chúng được lưu trữ trong danh sách có kích thước cố định. Để đáp ứng bài kiểm tra này, bạn có thể sử dụng lại một phần triển khai cũ của nó, sử dụng khả năng hiểu danh sách

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Lưu ý rằng bạn không còn phải chỉ định điều kiện lọc tùy chọn ở đây nữa, vì đã có một điều kiện ẩn đằng sau thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Những người theo chủ nghĩa thuần túy có thể nghĩ đến việc sử dụng cách hiểu theo tập hợp thay vì cách hiểu theo danh sách để truyền đạt sự thiếu đảm bảo cho thứ tự của các giá trị. Tuy nhiên, điều đó sẽ dẫn đến việc mất thông tin về các giá trị trùng lặp trong bảng băm. Protect yourself from such a possibility up front by writing another test case

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Ví dụ: nếu bạn có một bảng băm có tên và tuổi và nhiều người có cùng độ tuổi, thì

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

Cần kiểm tra các giá trị dự kiến, loại và số lượng của chúng. Tuy nhiên, bạn không thể so sánh trực tiếp hai danh sách vì các giá trị thực trong bảng băm có thể xuất hiện theo thứ tự không thể đoán trước. Để bỏ qua thứ tự trong bài kiểm tra của mình, bạn có thể chuyển đổi cả hai danh sách thành bộ hoặc sắp xếp chúng như trước đây. Thật không may, các bộ loại bỏ các bản sao tiềm năng, trong khi không thể sắp xếp khi danh sách chứa các loại không tương thích

Để kiểm tra một cách đáng tin cậy xem hai danh sách có chính xác các phần tử giống nhau của các loại tùy ý với các bản sao tiềm ẩn trong khi bỏ qua thứ tự của chúng hay không, bạn có thể sử dụng thành ngữ Python sau

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

It leverages the built-in

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

• các cửa sổ
• Linux + macOS

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Tiếp theo, nhập hàm

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Làm như vậy sẽ chuyển đổi các giá trị thành danh sách không có thứ tự, danh sách này xác định lại toán tử kiểm tra đẳng thức để nó không tính đến thứ tự khi so sánh các phần tử danh sách. Ngoài ra, các giá trị của bảng băm trống phải là một danh sách trống, trong khi thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Mặt khác, các khóa của bảng băm phải là duy nhất, vì vậy cần nhấn mạnh điều đó bằng cách trả về một tập hợp thay vì một danh sách các khóa. Rốt cuộc, các bộ theo định nghĩa là các bộ sưu tập các mục không có thứ tự không có bản sao

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

There’s no empty set literal in Python, so you have to call the built-in

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Nó giống với thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Điều này cũng nhắc nhở bạn về sự cần thiết của một trường hợp thử nghiệm tương tự mà bạn đã bỏ lỡ khi bao hàm thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Vì vậy, thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn không cần lo lắng về việc mất bất kỳ thông tin nào vì mỗi cặp khóa-giá trị là duy nhất. Tại thời điểm này, bạn sẽ lại ở giai đoạn xanh

Lưu ý rằng bạn có thể tận dụng thuộc tính

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Để bỏ qua thứ tự của các phần tử, hãy nhớ bọc các khóa từ điển và các cặp khóa-giá trị bằng các bộ trước khi thực hiện so sánh. Ngược lại, các giá trị trong bảng băm của bạn xuất hiện dưới dạng danh sách, vì vậy hãy đảm bảo sử dụng hàm

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Được rồi, bảng băm của bạn hiện đang thực sự bắt đầu hình thành

Báo cáo độ dài của bảng băm

Có 1 chi tiết nhỏ mà bạn cố ý để cho đơn giản đến tận bây giờ. Đó là độ dài của bảng băm của bạn, hiện đang báo cáo dung lượng tối đa của nó ngay cả khi chỉ có các vị trí trống. May mắn thay, không mất nhiều công sức để khắc phục điều này. Tìm hàm của bạn có tên là

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Để làm cho dung lượng không phụ thuộc vào độ dài, hãy sửa đổi phương thức đặc biệt của bạn

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'

>>> import string
>>> text = string.ascii_uppercase * 100_000_000

>>> text[:50]  # Show the first 50 characters
'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWX'

>>> len[text]
2600000000

Bạn vừa xóa dấu gạch dưới đầu tên biến. Nhưng sự thay đổi nhỏ đó hiện đang khiến cả đống bài kiểm tra kết thúc đột ngột với một lỗi và một số bài không thành công

Ghi chú. Các bài kiểm tra thất bại ít nghiêm trọng hơn vì các xác nhận của chúng đánh giá tới

>>> text[0]  # The first element
'A'

>>> text[len[text] // 2]  # The middle element
'A'

>>> text[-1]  # The last element, same as text[len[text] - 1]
'Z'