[ad_1]
Final Up to date on December 24, 2021
When an exception happens in a Python program, usually a traceback might be printed. Realizing methods to learn the traceback will help you simply determine the error and make a repair. On this tutorial we’re going see what the traceback can let you know.
After finishing this tutorial, you’ll know:
- Methods to learn a traceback
- Methods to print the decision stack with out exception
- What will not be proven within the traceback
Let’s get began.
Understanding Traceback in Python
Photograph by Marten Bjork, some rights reserved
Tutorial Overview
This tutorial is split into 4 components; they’re:
- The decision hierarchy of a easy program
- Traceback upon exception
- Triggering traceback manually
- An instance in mannequin coaching
The decision hierarchy of a easy program
Let’s think about a easy program:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
def indentprint(x, indent=0, prefix=“”, suffix=“”): if isinstance(x, dict): printdict(x, indent, prefix, suffix) elif isinstance(x, listing): printlist(x, indent, prefix, suffix) elif isinstance(x, str): printstring(x, indent, prefix, suffix) else: printnumber(x, indent, prefix, suffix)
def printdict(x, indent, prefix, suffix): areas = ” “ * indent print(areas + prefix + “{“) for n, key in enumerate(x): comma = “,” if n!=len(x)–1 else “” indentprint(x[key], indent+2, str(key)+“: “, comma) print(areas + “}” + suffix)
def printlist(x, indent, prefix, suffix): areas = ” “ * indent print(areas + prefix + “[“) for n, item in enumerate(x): comma = “,” if n!=len(x)–1 else “” indentprint(item, indent+2, “”, comma) print(spaces + “]” + suffix)
def printstring(x, indent, prefix, suffix): areas = ” “ * indent print(areas + prefix + ‘”‘ + str(x) + ‘”‘ + suffix)
def printnumber(x, indent, prefix, suffix): areas = ” “ * indent print(areas + prefix + str(x) + suffix)
information = { “a”: [{ “p”: 3, “q”: 4, “r”: [3,4,5], },{ “f”: “foo”, “g”: 2.71 },{ “u”: None, “v”: “bar” }], “c”: { “s”: [“fizz”, 2, 1.1], “t”: [] }, }
indentprint(information) |
This program is to print the Python dictionary information with indentations. It’s output is the next:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
{ a: [ { p: 3, q: 4, r: [ 3, 4, 5 ] }, { f: “foo”, g: 2.71 }, { u: None, v: “bar” } ], c: { s: [ “fizz”, 2, 1.1 ], t: [ ] } } |
This can be a quick program however features are calling one another. If we add a line at the start of every perform, we are able to reveal how the output is produced with the circulate of management:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
def indentprint(x, indent=0, prefix=“”, suffix=“”): print(f‘indentprint(x, {indent}, “{prefix}”, “{suffix}”)’) if isinstance(x, dict): printdict(x, indent, prefix, suffix) elif isinstance(x, listing): printlist(x, indent, prefix, suffix) elif isinstance(x, str): printstring(x, indent, prefix, suffix) else: printnumber(x, indent, prefix, suffix)
def printdict(x, indent, prefix, suffix): print(f‘printdict(x, {indent}, “{prefix}”, “{suffix}”)’) areas = ” “ * indent print(areas + prefix + “{“) for n, key in enumerate(x): comma = “,” if n!=len(x)–1 else “” indentprint(x[key], indent+2, str(key)+“: “, comma) print(areas + “}” + suffix)
def printlist(x, indent, prefix, suffix): print(f‘printlist(x, {indent}, “{prefix}”, “{suffix}”)’) areas = ” “ * indent print(areas + prefix + “[“) for n, item in enumerate(x): comma = “,” if n!=len(x)–1 else “” indentprint(item, indent+2, “”, comma) print(spaces + “]” + suffix)
def printstring(x, indent, prefix, suffix): print(f‘printstring(x, {indent}, “{prefix}”, “{suffix}”)’) areas = ” “ * indent print(areas + prefix + ‘”‘ + str(x) + ‘”‘ + suffix)
def printnumber(x, indent, prefix, suffix): print(f‘printnumber(x, {indent}, “{prefix}”, “{suffix}”)’) areas = ” “ * indent print(areas + prefix + str(x) + suffix) |
and the output might be messed with extra data:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 |
indentprint(x, 0, “”, “”) printdict(x, 0, “”, “”) { indentprint(x, 2, “a: “, “,”) printlist(x, 2, “a: “, “,”) a: [ indentprint(x, 4, “”, “,”) printdict(x, 4, “”, “,”) { indentprint(x, 6, “p: “, “,”) printnumber(x, 6, “p: “, “,”) p: 3, indentprint(x, 6, “q: “, “,”) printnumber(x, 6, “q: “, “,”) q: 4, indentprint(x, 6, “r: “, “”) printlist(x, 6, “r: “, “”) r: [ indentprint(x, 8, “”, “,”) printnumber(x, 8, “”, “,”) 3, indentprint(x, 8, “”, “,”) printnumber(x, 8, “”, “,”) 4, indentprint(x, 8, “”, “”) printnumber(x, 8, “”, “”) 5 ] }, indentprint(x, 4, “”, “,”) printdict(x, 4, “”, “,”) { indentprint(x, 6, “f: “, “,”) printstring(x, 6, “f: “, “,”) f: “foo”, indentprint(x, 6, “g: “, “”) printnumber(x, 6, “g: “, “”) g: 2.71 }, indentprint(x, 4, “”, “”) printdict(x, 4, “”, “”) { indentprint(x, 6, “u: “, “,”) printnumber(x, 6, “u: “, “,”) u: None, indentprint(x, 6, “v: “, “”) printstring(x, 6, “v: “, “”) v: “bar” } ], indentprint(x, 2, “c: “, “”) printdict(x, 2, “c: “, “”) c: { indentprint(x, 4, “s: “, “,”) printlist(x, 4, “s: “, “,”) s: [ indentprint(x, 6, “”, “,”) printstring(x, 6, “”, “,”) “fizz”, indentprint(x, 6, “”, “,”) printnumber(x, 6, “”, “,”) 2, indentprint(x, 6, “”, “”) printnumber(x, 6, “”, “”) 1.1 ], indentprint(x, 4, “t: “, “”) printlist(x, 4, “t: “, “”) t: [ ] } } |
So now we is aware of the order of how every perform is invoked. That is the concept of a name stack. At any level of time, once we run a line of code in a perform, we wish to know who invoked this perform.
Traceback upon exception
If we make one typo within the code like the next:
|
def printdict(x, indent, prefix, suffix): areas = ” “ * indent print(areas + prefix + “{“) for n, key in enumerate(x): comma = “,” if n!=len(x)–1 else “” indentprint(x[key], indent+2, str(key)+“: “, comma) print(areas + “}”) + suffix |
The typo is on the final line, which the closing bracket needs to be on the finish of line, not earlier than any +. The return worth of print() perform is a Python None object. And including one thing to None will set off an exception.
Should you run this program utilizing Python interpreter, you will notice this:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
{ a: [ { p: 3, q: 4, r: [ 3, 4, 5 ] } Traceback (most up-to-date name final): File “tb.py”, line 52, in indentprint(information) File “tb.py”, line 3, in indentprint printdict(x, indent, prefix, suffix) File “tb.py”, line 16, in printdict indentprint(x[key], indent+2, str(key)+”: “, comma) File “tb.py”, line 5, in indentprint printlist(x, indent, prefix, suffix) File “tb.py”, line 24, in printlist indentprint(merchandise, indent+2, “”, comma) File “tb.py”, line 3, in indentprint printdict(x, indent, prefix, suffix) File “tb.py”, line 17, in printdict print(areas + “}”) + suffix TypeError: unsupported operand kind(s) for +: ‘NoneType’ and ‘str’ |
The strains beginning with “Traceback (most up-to-date name final):” is the traceback. It’s the stack of your program on the time when your program encountered the exception. Within the above instance, the traceback is in “most up-to-date name final” order. Therefore your predominant perform is at prime whereas the one triggering the exception is at backside. So we all know the problem is contained in the perform printdict().
Often you will notice the error message on the finish of the traceback. On this instance, it’s a TypeError triggered by including None and string. However the traceback’s assist stops right here. You might want to work out which one is None and which one is string. By studying the traceback, we additionally know the exception-triggering perform printdict() is invokved by indentprint(), and it’s in flip invoked by printlist(), and so forth.
Should you run this in Jupyter pocket book, the next is the output:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 |
{ a: [ { p: 3, q: 4, r: [ 3, 4, 5 ] } ————————————————————————— TypeError Traceback (most up-to-date name final) /var/folders/6z/w0ltb1ss08l593y5xt9jyl1w0000gn/T/ipykernel_37031/2508041071.py in —-> 1 indentprint(x)
/var/folders/6z/w0ltb1ss08l593y5xt9jyl1w0000gn/T/ipykernel_37031/2327707064.py in indentprint(x, indent, prefix, suffix) 1 def indentprint(x, indent=0, prefix=””, suffix=””): 2 if isinstance(x, dict): —-> 3 printdict(x, indent, prefix, suffix) 4 elif isinstance(x, listing): 5 printlist(x, indent, prefix, suffix)
/var/folders/6z/w0ltb1ss08l593y5xt9jyl1w0000gn/T/ipykernel_37031/2327707064.py in printdict(x, indent, prefix, suffix) 14 for n, key in enumerate(x): 15 comma = “,” if n!=len(x)-1 else “” —> 16 indentprint(x[key], indent+2, str(key)+”: “, comma) 17 print(areas + “}”) + suffix 18
/var/folders/6z/w0ltb1ss08l593y5xt9jyl1w0000gn/T/ipykernel_37031/2327707064.py in indentprint(x, indent, prefix, suffix) 3 printdict(x, indent, prefix, suffix) 4 elif isinstance(x, listing): —-> 5 printlist(x, indent, prefix, suffix) 6 elif isinstance(x, str): 7 printstring(x, indent, prefix, suffix)
/var/folders/6z/w0ltb1ss08l593y5xt9jyl1w0000gn/T/ipykernel_37031/2327707064.py in printlist(x, indent, prefix, suffix) 22 for n, merchandise in enumerate(x): 23 comma = “,” if n!=len(x)-1 else “” —> 24 indentprint(merchandise, indent+2, “”, comma) 25 print(areas + “]” + suffix) 26
/var/folders/6z/w0ltb1ss08l593y5xt9jyl1w0000gn/T/ipykernel_37031/2327707064.py in indentprint(x, indent, prefix, suffix) 1 def indentprint(x, indent=0, prefix=””, suffix=””): 2 if isinstance(x, dict): —-> 3 printdict(x, indent, prefix, suffix) 4 elif isinstance(x, listing): 5 printlist(x, indent, prefix, suffix)
/var/folders/6z/w0ltb1ss08l593y5xt9jyl1w0000gn/T/ipykernel_37031/2327707064.py in printdict(x, indent, prefix, suffix) 15 comma = “,” if n!=len(x)-1 else “” 16 indentprint(x[key], indent+2, str(key)+”: “, comma) —> 17 print(areas + “}”) + suffix 18 19 def printlist(x, indent, prefix, suffix):
TypeError: unsupported operand kind(s) for +: ‘NoneType’ and ‘str’ |
The knowledge is actually the identical, nevertheless it provides you the strains earlier than. and after every perform name.
Triggering traceback manually
The simplest technique to print a traceback is so as to add a increase assertion to manually create an exception. However this may even terminate your program. If we wish to print the stack at any time even with none exception, we are able to accomplish that like the next:
|
import traceback
def printdict(x, indent, prefix, suffix): areas = ” “ * indent print(areas + prefix + “{“) for n, key in enumerate(x): comma = “,” if n!=len(x)–1 else “” indentprint(x[key], indent+2, str(key)+“: “, comma) traceback.print_stack() # print the present name stack print(areas + “}” + suffix) |
The road traceback.print_stack() will print the present name stack.
However certainly, we regularly wish to print the stack solely when there may be error (so we be taught extra about why it’s so). The extra widespread use case is the next:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import traceback import random
def compute(): n = random.randint(0, 10) m = random.randint(0, 10) return n/m
def compute_many(n_times): strive: for _ in vary(n_times): x = compute() print(f“Accomplished {n_times} instances”) besides: print(“One thing flawed”) traceback.print_exc()
compute_many(100) |
This can be a typical sample for repeatedly calculating a perform, equivalent to Monte Carlo simulation. But when we aren’t cautious sufficient, we could run into some error, equivalent to within the above instance, we could have division by zero. The issue is, in case of extra sophisticated computation you may’t simply spot the flaw. Resembling in above, the problem buried inside the decision to compute(). Subsequently it’s useful to know how we get the error. However on the similar time we wish to deal with the case of error somewhat than let your entire program terminate. If we use the try-catch assemble, the traceback is not going to be print by default. Subsequently we’d like the use the traceback.print_exc() assertion to do it manually.
Really we are able to have the traceback extra elaborated. As a result of the traceback is the decision stack and certainly we are able to study every perform within the name stack and verify the variables in every degree. Within the sophisticated case, that is the perform I often use to do extra detailed hint:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
def print_tb_with_local(): “”“Print stack hint with native variables. This doesn’t should be in exception. Print is utilizing the system’s print() perform to stderr. ““” import traceback, sys tb = sys.exc_info()[2] stack = [] whereas tb: stack.append(tb.tb_frame) tb = tb.tb_next() traceback.print_exc() print(“Locals by body, most up-to-date name first”, file=sys.stderr) for body in stack: print(“Body {0} in {1} at line {2}”.format( body.f_code.co_name, body.f_code.co_filename, body.f_lineno), file=sys.stderr) for key, worth in body.f_locals.gadgets(): print(“tpercent20s = “ % key, file=sys.stderr) strive: if ‘__repr__’ in dir(worth): print(worth.__repr__(), file=sys.stderr) elif ‘__str__’ in dir(worth): print(worth.__str__(), file=sys.stderr) else: print(worth, file=sys.stderr) besides: print(“”, file=sys.stderr) |
An instance in mannequin coaching
The decision stack as reported within the traceback has a limitation: You possibly can solely see the Python features. It needs to be simply fantastic for this system you wrote however many giant libraries in Python have a part of them written in one other language and compiled into binary. An instance is Tensorflow. All of the underlying operation are in binary for the efficiency. Therefore when you run the next code, you will notice one thing totally different:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import numpy as np
sequence = np.arange(0.1, 1.0, 0.1) # 0.1 to 0.9 n_in = len(sequence) sequence = sequence.reshape((1, n_in, 1))
# outline mannequin import tensorflow as tf from tensorflow.keras.layers import LSTM, RepeatVector, Dense, TimeDistributed, Enter from tensorflow.keras import Sequential, Mannequin
mannequin = Sequential([ LSTM(100, activation=“relu”, input_shape=(n_in+1, 1)), RepeatVector(n_in), LSTM(100, activation=“relu”, return_sequences=True), TimeDistributed(Dense(1)) ]) mannequin.compile(optimizer=“adam”, loss=“mse”)
mannequin.match(sequence, sequence, epochs=300, verbose=0) |
The input_shape parameter to the primary LSTM layer within the mannequin needs to be (n_in, 1) to match the enter information, somewhat than (n_in+1, 1). This code will print the next error when you invoked the final line:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Traceback (most up-to-date name final): File “trback3.py”, line 20, in mannequin.match(sequence, sequence, epochs=300, verbose=0) File “/usr/native/lib/python3.9/site-packages/keras/utils/traceback_utils.py”, line 67, in error_handler increase e.with_traceback(filtered_tb) from None File “/usr/native/lib/python3.9/site-packages/tensorflow/python/framework/func_graph.py”, line 1129, in autograph_handler increase e.ag_error_metadata.to_exception(e) ValueError: in consumer code:
File “/usr/native/lib/python3.9/site-packages/keras/engine/coaching.py”, line 878, in train_function * return step_function(self, iterator) File “/usr/native/lib/python3.9/site-packages/keras/engine/coaching.py”, line 867, in step_function ** outputs = mannequin.distribute_strategy.run(run_step, args=(information,)) File “/usr/native/lib/python3.9/site-packages/keras/engine/coaching.py”, line 860, in run_step ** outputs = mannequin.train_step(information) File “/usr/native/lib/python3.9/site-packages/keras/engine/coaching.py”, line 808, in train_step y_pred = self(x, coaching=True) File “/usr/native/lib/python3.9/site-packages/keras/utils/traceback_utils.py”, line 67, in error_handler increase e.with_traceback(filtered_tb) from None File “/usr/native/lib/python3.9/site-packages/keras/engine/input_spec.py”, line 263, in assert_input_compatibility increase ValueError(f’Enter {input_index} of layer “{layer_name}” is ‘
ValueError: Enter 0 of layer “sequential” is incompatible with the layer: anticipated form=(None, 10, 1), discovered form=(None, 9, 1) |
Should you have a look at the traceback, you can not actually see the entire name stack. For instance, the highest body you referred to as mannequin.match() however the second body is from a perform named error_handler(). Which you can not see how the match() perform triggered that. It is because Tensorflow is very optimized. A whole lot of stuff is hidden in compiled code and never seen by the Python interpreter.
On this case, it’s important to patiently learn the traceback and discover the clue to the trigger. In fact, often the error message ought to provide you with some helpful hints as effectively.
Additional Studying
This part offers extra sources on the subject in case you are trying to go deeper.
Books
Python Official Documentation
Abstract
On this tutorial, you found methods to learn and print the traceback from a Python program.
Particularly, you discovered:
- What data the traceback tells you
- Methods to print a traceback at any level of your program with out elevating an exception
Within the subsequent submit, we are going to see how we are able to navigate the decision stack contained in the Python debugger.
[ad_2]
