Hướng dẫn avoid keyerror in dictionary python - tránh lỗi keyerror trong từ điển python

Trong bài viết này, chúng ta hãy học

• Các trường hợp ngoại lệ KeyError là gì,
• Tại sao chúng xảy ra,
• làm thế nào để ngăn chặn chúng xảy ra và
• Nếu chúng vẫn xảy ra thì thông tin quan trọng chúng ta cần đăng nhập để gỡ lỗi trong tương lai và
• Cách đăng nhập thông tin này.

Trong hành trình trở thành một thợ thủ công Python thành thạo, chúng ta cần học cách thiết kế mã không thể chấp nhận được và bài viết này là một bước hướng tới mục tiêu đó!

Nếu đây là lần đầu tiên thấy một sự cố chương trình Python, tôi khuyên bạn nên đọc bài viết trong liên kết dưới đây để trau dồi kỹ năng xử lý ngoại lệ của bạn trước khi tiếp tục với chương trình này.

Ngoại lệ trong Python: Mọi thứ bạn cần biết!

Có 3 cách chính để xử lý các ngoại lệ KeyError trong Python. 2 cách đầu tiên là về việc ngăn chặn chúng. Chúng tôi có thể ngăn chặn lỗi

• bằng cách sử dụng phương thức get ()
• bằng cách sử dụng phương thức setDefault ()

2 phương pháp này được cung cấp cho chúng tôi bởi lớp Dict

Cách thứ 3 là

• Bắt chúng từ ngoại trừ và ghi nhật ký thông tin cần thiết để gỡ lỗi sau.

Đối với những người bạn vội vàng, hãy sử dụng bảng nội dung bên dưới để nhảy vào phần quan tâm của bạn.

Hãy để chúng tôi bắt đầu bằng cách tìm hiểu ý nghĩa của KeyError.

KeyError là gì?

Từ điển là cấu trúc dữ liệu tích hợp trong Python được sử dụng để lưu trữ các cặp giá trị khóa. Ví dụ, dòng mã này
For example, this line of code

superDict = {'a':'aquaman', 'b':'batman'}

sẽ tạo ra một từ điển như thế này

Ở đây, Superdict từ điển được khởi tạo với 2 cặp giá trị khóa.

Bây giờ nói rằng chúng tôi muốn truy cập dict bằng một khóa chưa có bên trong nó như thế này

print(superDict['c']) # Expecting catwoman here!

Sau đó, Python sẽ nâng một Keyerror như thế này.

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Tôi đoán bạn đã trải nghiệm một cái gì đó tương tự như thế này trước khi đến đây. Vì vậy, hãy chắc chắn rằng nếu cặp giá trị khóa bạn đang cố gắng truy cập đã được khởi tạo đúng.

Tóm lại, khi làm việc với Dicts in Python, nếu chúng ta đang cố gắng sử dụng một phím không phù hợp với bất kỳ phím nào được lưu trữ bên trong đối tượng DictWhen working with dicts in Python, if we are trying to use a Key that does not match any of the keys stored inside the dict object, Python will raise a KeyError

Python cung cấp một số thủ thuật thú vị để đảm bảo các chương trình của chúng tôi không gặp sự cố nếu các lỗi đó xảy ra.

Để ngăn chặn các ngoại lệ KeyError, Python cung cấp cho chúng tôi 2 phương pháp hữu ích như là một phần của lớp từ điển.

• nhận () phương thức và
• Phương thức setDefault ()

Cả hai phương pháp này đều hữu ích trong 2 kịch bản khác nhau, chúng ta hãy xem cách sử dụng chúng và sử dụng nào trong kịch bản nào.

Trước tiên chúng ta bắt đầu với phương thức get ().

Phương pháp số 1: Ngăn chặn các ngoại lệ KeyError bằng phương thức get ()

Hãy xem mã bên dưới

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Tại đây, nếu Superdict không chứa khóa ‘C, phương thức Get () sẽ đặt giá trị cho biến X là‘ Cat Woman thay vì ném một ngoại lệ.

Chạy mã trên sẽ dẫn đến đầu ra bên dưới

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Bây giờ nếu chúng ta có một cái nhìn về các đối tượng được tạo bởi chương trình này, bạn sẽ thấy rằng Superdict từ điển vẫn sẽ chỉ có 2 cặp giá trị khóa và biến X sẽ chứa chuỗi ‘Cat Woman, như được hiển thị bên dưới.

Điều này cũng có thể được nhìn thấy tại dấu nhắc Python

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Khi nào nên sử dụng phương thức get ()?

Nếu bạn muốn tránh ngoại lệ KeyError và tránh thêm bất kỳ cặp giá trị khóa nào vào từ điển thì hãy sử dụng phương thức get ().

Phương pháp số 2: Ngăn chặn các ngoại lệ KeyError bằng phương thức setDefault ()

Hãy xem mã dưới đây.

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Trong Line-2, chúng tôi đã sử dụng phương thức setDefault () để tránh keyError và trong dòng-3, chúng tôi đã sử dụng phương thức get () để tránh keyError. Lưu ý rằng cả hai khóa ’C, và’ D, không có sẵn trong Superdict của chúng tôi

Hãy để chúng tôi chạy mã này và xem những gì xảy ra.

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Như bạn có thể thấy mã chạy tốt mà không cần khóa!

Hãy để chúng tôi có một cái nhìn nhanh về Superdict từ điển của chúng tôi!

Như bạn có thể thấy trong ảnh chụp màn hình ở trên, phương thức setDefault () đã thêm cặp giá trị khóa mới ‘C,

Khi nào nên sử dụng phương thức setDefault ()?

Sử dụng phương thức setDefault () nếu bạn muốn tránh ngoại lệ KeyError và thêm một cặp giá trị khóa vào từ điển của bạn trong quá trình.

Phương pháp số 3: Ghi nhật ký thông tin quan trọng về KeyError từ mệnh đề ngoại trừ

Có những tình huống/trường hợp bạn không thể làm nhiều việc ngăn chặn Keyerrors và tất cả những gì bạn có thể làm là đăng nhập thông tin và gỡ lỗi ngoại lệ sau này. Trong những tình huống như vậy, chúng ta cần đăng nhập các thông tin quan trọng để chúng ta có manh mối cần thiết để gỡ lỗi vấn đề này.

Hãy cho chúng tôi xem những thông tin nào chúng tôi có thể nhận được từ các ngoại lệ của KeyError và cách đăng nhập chúng.

Chúng ta hãy bắt đầu bằng cách xem xét thông báo lỗi mà trình thông dịch ném vào chúng tôi bằng cách buộc thủ công một KeyError bằng cách sử dụng câu lệnh RAISE.

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Chạy dòng mã trên để lại cho chúng tôi thông báo lỗi sau

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Như bạn có thể thấy, chúng tôi được cung cấp số dòng chính xác (dòng 1) và loại ngoại lệ (KeyError), cả hai đều là thông tin quan trọng để giúp chúng tôi gỡ lỗi ngoại lệ sau này. Nhưng nếu chúng tôi để cho thông dịch viên Python làm hỏng chương trình của chúng tôi, chúng tôi sẽ không thể đăng nhập thông tin này, cũng là người dùng chương trình của chúng tôi có thể không thích quan điểm về thông báo lỗi kỹ thuật/đáng sợ như vậy.

Nếu đây là tuyên bố nâng cao đầu tiên của bạn và bạn tò mò tìm hiểu thêm về cách sử dụng công cụ này để nâng cao trình độ Python của bạn, tôi khuyên bạn nên thêm bài viết trong liên kết dưới đây vào danh sách đọc của bạn và đọc nó sau khi bạn đọc xong cái này!

Python: Ném/nâng một ngoại lệ theo cách thủ công

Quay trở lại bài viết này, hãy cho chúng tôi xem cách đăng nhập các thông tin cần thiết bằng cách sử dụng các điều khoản trừ thử.

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Trong mã trên, chúng tôi đã đặt mã có vấn đề trong mệnh đề thử và chúng tôi đang sử dụng một mệnh đề ngoại trừ để bắt các ngoại lệ KeyError. Ngay khi bắt được, chúng tôi sẽ gán đối tượng ngoại lệ bị bắt cho biến có tên ERR và in thông tin có bên trong đối tượng đó bằng cách in dòng (Khóa không xác định: Khóa, ERR)

Chúng tôi cũng đã nhập mô -đun TraceBack trong Python được sử dụng trong dòng cuối cùng để giúp chúng tôi hiểu dòng mã nào gây ra lỗi.

Chạy mã ở trên, chúng ta có thể thấy một cái gì đó giống như

functionTable = {"ADD":"00",
         "SUB":"01",
         "LD" :"10"}

registerTable = {"R0":"00",
         "R1":"00",
         "R2":"00",
         "R3":"00"}

accumulatorTable = {"A"  :"00",
            "B"  :"10",
            "A+B":"11"}

conditionTable = {"JH":"1"}

valueTable = {"0":"0000",
          "1":"0001",
          "2":"0010",
          "3":"0011",
          "4":"0100",
          "5":"0101",
          "6":"0110",
          "7":"0111",
          "8":"1000",
          "9":"1001",
          "10":"1010",
          "11":"1011",
          "12":"1100",
          "13":"1101",
          "14":"1110",
          "15":"1111"}

source = "LD R3 15"

newS = source.split(" ")

for item in newS:

        if item in functionTable[item]:
            functionField = functionTable[item]
        else:
            functionField = "00"

        if item in registerTable[item]:
            registerField = registerTable[item]
        else:
            registerField = "00"

print(functionField + registerField)

Như bạn có thể thấy, chúng tôi đã in ra thông báo lỗi như chúng tôi muốn!

Nếu bạn nhìn kỹ, có 3 mẩu thông tin trong thông báo lỗi này

1. Giá trị bên trong đối tượng ngoại lệ bị bắt (ERR), là chuỗi ‘C, khóa gây ra lỗi!
2. TraceBack hiển thị vị trí trong mã của chúng tôi, ngoại lệ này đã được nêu ra từ, Line-3 trong trường hợp này và
3. Loại ngoại lệ, là keyerror

Nếu bạn tò mò muốn biết cách kiểm soát việc ghi nhật ký của từng phần riêng lẻ để bạn có thể có nhật ký lỗi gọn gàng hơn, tôi có toàn bộ bài viết dành riêng cho điều đó! Bạn có thể đọc nó trong liên kết bên dưới.
You can read that in the link below.

Ngoại lệ Python: Nhận và xử lý các thông báo lỗi dưới dạng chuỗi.

Và với điều đó, tôi sẽ kết thúc bài viết này.

Tôi hy vọng bạn thấy bài viết này hữu ích trên hành trình làm chủ Python của bạn!

Hãy chia sẻ bài viết này với bạn bè và đồng nghiệp của bạn!