programming python

Làm cách nào để bạn xử lý lỗi thời gian chạy trong python?

Tăng một ngoại lệ

Là nhà phát triển Python, bạn có thể chọn ném ngoại lệ nếu có điều kiện xảy ra

Để ném [hoặc tăng] một ngoại lệ, hãy sử dụng từ khóa

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      1 L = [1, 2, 3]
----> 2 L[1000]

IndexError: list index out of range

Thí dụ

Báo lỗi và dừng chương trình nếu x nhỏ hơn 0

x = -1

nếu x < 0.
raise Exception["Xin lỗi, không có số nào dưới 0"]

Tự mình thử »

Từ khóa

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      1 L = [1, 2, 3]
----> 2 L[1000]

IndexError: list index out of range

6 được sử dụng để đưa ra một ngoại lệ

Bạn có thể xác định loại lỗi nào sẽ gây ra và văn bản sẽ in cho người dùng

Thí dụ

Tăng TypeError nếu x không phải là số nguyên

x = "xin chào"

nếu không gõ[x] là int.
tăng TypeError["Chỉ cho phép số nguyên"]

Tự mình thử »

Bất kể kỹ năng lập trình của bạn là gì, cuối cùng bạn sẽ mắc lỗi viết mã. Những sai lầm như vậy có ba hương vị cơ bản

Lỗi cú pháp. Lỗi code không hợp lệ Python [thường dễ sửa]
lỗi thời gian chạy. Lỗi trong đó mã hợp lệ về mặt cú pháp không thực thi được, có thể do đầu vào của người dùng không hợp lệ [đôi khi dễ sửa]
lỗi ngữ nghĩa. Lỗi logic. mã thực thi mà không gặp sự cố, nhưng kết quả không như bạn mong đợi [thường rất khó theo dõi và sửa lỗi]

Ở đây chúng ta sẽ tập trung vào cách xử lý sạch sẽ các lỗi thời gian chạy. Như chúng ta sẽ thấy, Python xử lý các lỗi thời gian chạy thông qua khung xử lý ngoại lệ của nó

Lỗi thời gian chạy¶

Nếu bạn đã thực hiện bất kỳ mã hóa nào trong Python, bạn có thể gặp lỗi thời gian chạy. Chúng có thể xảy ra theo nhiều cách

Ví dụ: nếu bạn cố gắng tham chiếu một biến không xác định

Trong 3]

print[Q]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Hoặc nếu bạn thử một thao tác không được xác định

Trong [4]

1 + 'abc'

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

Hoặc bạn có thể đang cố gắng tính toán một kết quả không xác định về mặt toán học

Trong [5]

2 / 0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback [most recent call last]
 in []
----> 1 2 / 0

ZeroDivisionError: division by zero

Hoặc có thể bạn đang cố truy cập một phần tử trình tự không tồn tại

Trong [6]

L = [1, 2, 3]
L[1000]

---------------------------------------------------------------------------
IndexError                                Traceback [most recent call last]
 in []
      1 L = [1, 2, 3]
----> 2 L[1000]

IndexError: list index out of range

Lưu ý rằng trong mỗi trường hợp, Python đủ tử tế để không chỉ đơn giản chỉ ra rằng đã xảy ra lỗi mà còn đưa ra một ngoại lệ có ý nghĩa bao gồm thông tin về chính xác lỗi đã xảy ra, cùng với dòng mã chính xác xảy ra lỗi. Có quyền truy cập vào các lỗi có ý nghĩa như thế này vô cùng hữu ích khi cố gắng truy tìm gốc rễ của các vấn đề trong mã của bạn

Bắt ngoại lệ.

2 / 0

2 và

2 / 0

3¶

Công cụ chính mà Python cung cấp cho bạn để xử lý các ngoại lệ trong thời gian chạy là

2 / 0

2. mệnh đề

2 / 0

3. Cấu trúc cơ bản của nó là thế này

Trong [7]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Lưu ý rằng khối thứ hai ở đây không được thực thi. điều này là do khối đầu tiên không trả về lỗi. Hãy đặt một câu có vấn đề vào khối

2 / 0

2 và xem điều gì sẽ xảy ra

Trong [8]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Ở đây chúng ta thấy rằng khi lỗi xuất hiện trong câu lệnh

2 / 0

2 [trong trường hợp này là một câu lệnh

2 / 0

8], lỗi đã được bắt và câu lệnh

2 / 0

3 được thực thi

Một cách mà điều này thường được sử dụng là kiểm tra đầu vào của người dùng trong một chức năng hoặc một đoạn mã khác. Ví dụ: chúng ta có thể muốn có một hàm bắt phép chia cho 0 và trả về một số giá trị khác, có thể là một số lớn phù hợp như $10^{100}$

Trong [9]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Trong [10]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Ra[10]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Trong [11]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Ra[11]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Tuy nhiên, có một vấn đề tế nhị với mã này. điều gì xảy ra khi một loại ngoại lệ khác xuất hiện?

Trong [12]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Ra[12]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Phép chia một số nguyên và một chuỗi sẽ tạo ra một

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback [most recent call last]
 in []
----> 1 2 / 0

ZeroDivisionError: division by zero

0, mà mã quá sốt sắng của chúng tôi bắt được và giả định là một

2 / 0

8. Vì lý do này, gần như luôn luôn là một ý tưởng tốt hơn để nắm bắt các ngoại lệ một cách rõ ràng

Trong [13]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Trong [14]

1 + 'abc'

Ra[14]

---------------------------------------------------------------------------
NameError                                 Traceback [most recent call last]
 in []
----> 1 print[Q]

NameError: name 'Q' is not defined

Trong [15]

1 + 'abc'

1 + 'abc'

Hiện tại, chúng tôi chỉ bắt các lỗi chia không và để tất cả các lỗi khác chuyển qua không sửa đổi

Tăng ngoại lệ.

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback [most recent call last]
 in []
----> 1 2 / 0

ZeroDivisionError: division by zero

2¶

Chúng tôi đã thấy giá trị của việc có các ngoại lệ thông tin khi sử dụng các phần của ngôn ngữ Python. Việc sử dụng các ngoại lệ mang tính thông tin trong mã bạn viết cũng có giá trị như nhau để những người dùng mã của bạn [trước hết là chính bạn. ] có thể tìm ra nguyên nhân gây ra lỗi của họ

Cách bạn đưa ra các ngoại lệ của riêng mình là với câu lệnh

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback [most recent call last]
 in []
----> 1 2 / 0

ZeroDivisionError: division by zero

2. Ví dụ

Trong [16]

1 + 'abc'

1 + 'abc'

Để làm ví dụ về việc điều này có thể hữu ích ở đâu, hãy quay lại hàm

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback [most recent call last]
 in []
----> 1 2 / 0

ZeroDivisionError: division by zero

4 mà chúng ta đã xác định trước đó

Trong [17]

1 + 'abc'

Một vấn đề tiềm ẩn ở đây là giá trị đầu vào có thể âm. Điều này hiện sẽ không gây ra bất kỳ lỗi nào trong chức năng của chúng tôi, nhưng chúng tôi có thể muốn cho người dùng biết rằng giá trị âm 55 không được hỗ trợ. Lỗi xuất phát từ các giá trị tham số không hợp lệ, theo quy ước, dẫn đến việc tăng

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback [most recent call last]
 in []
----> 1 2 / 0

ZeroDivisionError: division by zero

Trong [18]

1 + 'abc'

Trong 19]

1 + 'abc'

Hết[19]

1 + 'abc'

Trong 20]

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

Bây giờ người dùng biết chính xác lý do tại sao đầu vào không hợp lệ và thậm chí có thể sử dụng

2 / 0

2. Khối

2 / 0

3 để xử lý nó

Trong [21]

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

Tìm hiểu sâu hơn về ngoại lệ¶

Tóm lại, tôi muốn đề cập ở đây một số khái niệm khác mà bạn có thể gặp phải. Tôi sẽ không đi vào chi tiết về các khái niệm này cũng như cách thức và lý do sử dụng chúng, mà thay vào đó, tôi sẽ chỉ cho bạn biết cú pháp để bạn có thể tự khám phá thêm

Truy cập thông báo lỗi¶

Đôi khi trong một

2 / 0

2 / 0

3, bạn muốn có thể làm việc với chính thông báo lỗi đó. Điều này có thể được thực hiện với từ khóa

L = [1, 2, 3]
L[1000]

Trong [22]

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

Với mẫu này, bạn có thể tùy chỉnh thêm việc xử lý ngoại lệ của chức năng của mình

Xác định các ngoại lệ tùy chỉnh¶

Ngoài các ngoại lệ có sẵn, có thể xác định các ngoại lệ tùy chỉnh thông qua kế thừa lớp. Chẳng hạn, nếu bạn muốn một loại

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback [most recent call last]
 in []
----> 1 2 / 0

ZeroDivisionError: division by zero

6 đặc biệt, bạn có thể làm điều này

Trong [23]

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

Điều này sẽ cho phép bạn sử dụng một

2 / 0

2. Khối

2 / 0

3 chỉ phát hiện loại lỗi này

Trong [24]

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

---------------------------------------------------------------------------
TypeError                                 Traceback [most recent call last]
 in []
----> 1 1 + 'abc'

TypeError: unsupported operand type[s] for +: 'int' and 'str'

Bạn có thể thấy điều này hữu ích khi bạn phát triển mã tùy chỉnh hơn

2 / 0

2 / 0

L = [1, 2, 3]
L[1000]

L = [1, 2, 3]
L[1000]

8¶

Ngoài

2 / 0

2 và

2 / 0

3, bạn có thể sử dụng các từ khóa

L = [1, 2, 3]
L[1000]

7 và

L = [1, 2, 3]
L[1000]

8 để điều chỉnh thêm việc xử lý ngoại lệ trong mã của mình. Cấu trúc cơ bản là thế này

Trong [25]

2 / 0

2 / 0

Tiện ích của

L = [1, 2, 3]
L[1000]

7 ở đây rất rõ ràng, nhưng mục đích của

L = [1, 2, 3]
L[1000]

8 là gì? . Tôi thường thấy nó được sử dụng để thực hiện một số công việc dọn dẹp sau khi một hoạt động hoàn tất

Lỗi thời gian chạy trong ví dụ Python là gì?

Dưới đây là một số ví dụ về các lỗi thời gian chạy phổ biến mà bạn chắc chắn sẽ gặp phải. Tên biến và hàm sai chính tả hoặc viết hoa sai chính tả . Nỗ lực thực hiện các phép toán [chẳng hạn như phép toán] trên dữ liệu không đúng loại [ví dụ:. cố gắng trừ hai biến chứa giá trị chuỗi]

Xử lý lỗi thời gian chạy là gì?

Trình xử lý lỗi chỉ định điều gì sẽ xảy ra trong một quy trình khi xảy ra lỗi . Ví dụ: bạn có thể muốn quy trình kết thúc nếu xảy ra lỗi nhất định hoặc bạn có thể muốn sửa điều kiện gây ra lỗi và tiếp tục thực hiện.

Tăng một ngoại lệ

Thí dụ

Thí dụ

Lỗi thời gian chạy¶

Bắt ngoại lệ. 2 / 0 2 và 2 / 0 3¶

Tăng ngoại lệ. --------------------------------------------------------------------------- ZeroDivisionError Traceback [most recent call last] in [] ----> 1 2 / 0 ZeroDivisionError: division by zero2¶

Tìm hiểu sâu hơn về ngoại lệ¶

Truy cập thông báo lỗi¶

Xác định các ngoại lệ tùy chỉnh¶

2 / 0 2. 2 / 0 3. L = [1, 2, 3] L[1000] 7. L = [1, 2, 3] L[1000] 8¶

Lỗi thời gian chạy trong ví dụ Python là gì?

Xử lý lỗi thời gian chạy là gì?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

Bắt ngoại lệ.
2 / 0
2 và
2 / 0
3¶

Tăng ngoại lệ.
--------------------------------------------------------------------------- ZeroDivisionError Traceback [most recent call last] in [] ----> 1 2 / 0 ZeroDivisionError: division by zero
2¶

2 / 0
2.
2 / 0
3.
L = [1, 2, 3] L[1000]
7.
L = [1, 2, 3] L[1000]
8¶