რა არის ჰეში და როგორ გამოიყენება Python-ის ლექსიკებში?

ჰეში (ან ჰეშ-ღირებულება) არის რიცხვითი მნიშვნელობა ფიქსირებული სიგრძის, რომელიც გამოითვლება ობიექტის შიგთავსზე დაფუძნებული ჰეშ-ფუნქციის საშუალებით. კარგი ჰეშ-ფუნქცია უზრუნველყოფს დეტერმინიზმს (ანუ იგივე ობიექტი ყოველთვის იძლევა ერთსა და იმავე ჰეშს) და ცდილობს განაწილების თანაბარობას სხვადასხვა ობიექტებს შორის.

Python-ში ლექსიკები (dict ტიპი) იყენებენ ჰეშირებას ეფექტური შენახვისა და ძიებისთვის "საკლავი-ღირებულების" წყვილების. საკლავები უნდა იყოს ჰეშირებადი, ანუ უნდა ჰქონდეთ __hash__() მეთოდი და იყოს იმუტაბელური ან ჰქონდეთ __eq__() და __hash__() რეალიზაცია, რომელიც უზრუნველყოფს, რომ თანაბარი ობიექტები ჰქონდეთ ერთსა და იმავე ჰეში.

ლექსიკის მუშაობის პროცესი ჰეშებით:

1. ჩამატება: როდესაც დამატებულია წყვილი (საკლავი, მნიშვნელობა), გამოითვლება საკლავის ჰეში. ჰეშის საფუძველზე განსაზღვრულია საშუალო ადგილი (კასეტა ან "ბაკეტი") ამ წყვილის შენახვისთვის მეხსიერებაში. თუ რამდენიმე საკლავი აქვს ერთსა და იმავე ჰეშს (კოლიზია), ამ წყვილებს ინახავენ ამ ბაკეტში, ხშირად დაკავშირებული სია ან სხვა კოლიზიის გადაჭრის მექანიზმი.
2. ძებნა: ძებნის დროს, გამოითვლება გადაცემული საკლავის ჰეში. ჰეშის გამოყენებით, ლექსიკი სწრაფად პოულობს შესაბამის ბაკეტს. შემდეგ, ამ ბაკეტში, შედარება ხდება საკლავების (__eq__()) საშუალებით, რათა იპოვოს საჭირო საკლავი და მიიღოს დაკავშირებული მნიშვნელობა.

ჰეშირების უპირატესობები:

• ეფექტურობა: საშუალოდ, დამატება, წაშლა და ძიების ოპერაციები ხორციელდება მუდმივი დროის სირთულით O(1), ლექსიკის ზომის მიუხედავად.
• სწრაფი წვდომა: ჰეში საშუალებას აძლევს სწრაფად მიაღწიო მონაცემთა მოსალოდნელ ადგილს, გამოტოვებს ყველა ელემენტის გადამოწმებას.

შეზღუდვები და სპეციფიკაციები:

• ჰეშირებადი საკლავები: როგორც აღინიშნა, საკლავები უნდა იყოს ჰეშირებადი. მუტაბელური ტიპები, როგორიცაა სია (list) და ნაკრები (set), ჩვეულებრივ, არ არის ჰეშირებადი და არ შეიძლება გამოყენებულ იქნას საკლავებად.
• კოლიზიები: მიუხედავად იმისა, რომ ჰეშ-ფუნქციები ცდილობენ მინიმუმამდე დაიყვანონ კოლიზიები, ისინი შეიძლება მოხდეს, რაც შეიძლება ოდნავ გაანელოს ოპერაციები ყველაზე უარესი შემთხვევაშიც (მოქმედებს O(1) კონსტანტაზე).
• სორტი: Python 3.7-მდე, ლექსიკების ელემენტების სორტი დამოკიდებული იყო დამატების წესზე და საკლავის ჰეშებზე. 3.7-დან, ლექსიკები ინახავენ დამატების წესს, როგორც გვერდითი ეფექტი განხორციელების, მაგრამ ეს არ არის ჰეშირების ნაწილია.

მაგალითი ჰეშირებადი და ჰეშირებადი არ ობიექტების:

# ჰეშირებადი ობიექტი (არამოძრავი)
string_key = "hello"
int_key = 123
tuple_key = (1, 2)

print(hash(string_key))
print(hash(int_key))
print(hash(tuple_key))

# ჰეშირებადი არ ობიექტი (მოძრავი)
list_key = [1, 2]
# print(hash(list_key)) # გამოიწვევს TypeError-ს

# მაგალითი ლექსიკში გამოყენებისთვის
my_dict = {
    string_key: "world",
    int_key: 456,
    tuple_key: "ტუპლე"
}

print(my_dict[string_key])
print(my_dict[int_key])
print(my_dict[tuple_key])

ამიტომ, ჰეში არის ძირითადი მექანიზმი, რომელიც საშუალებას აძლევს Python-ის ლექსიკებს მიაღწიონ მაღალი ეფექტურობის ოპერაციებს, რომლებიც დაფუძნებულია სწრაფ გამოთვლაზე საკლავის რიცხვითი გამოსახულების.