五、回溯（trackback）

已于 2023-09-27 16:11:26 修改
阅读量1.2k 收藏 4
点赞数 4
分类专栏： Agorithm 文章标签： 算法 c++
于 2023-09-22 10:17:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54447296/article/details/133157961
版权

文章目录

一、算法定义

抽象地说，解决一个回溯问题，实际上就是遍历一棵决策树的过程，树的每个叶子节点存放着一个合法答案。你把整棵树遍历一遍，把叶子节点上的答案都收集起来，就能得到所有的合法答案。
站在回溯树的一个节点上，你只需要思考 3 个问题：
1、路径：也就是已经做出的选择。
2、选择列表：也就是你当前可以做的选择。
3、结束条件：也就是到达决策树底层，无法再做选择的条件。
在这里插入图片描述

二、经典例题

（一）排列

1.46.全排列

（1）思路

在这里插入图片描述

（2）代码
class Solution {
public:
vector<vector<int>> res;
    void dfs(vector<int>& nums) {
        vector<int> path;
        vector<bool> used(nums.size(),false);
        trackback(nums,path,used);
    }
    void trackback(vector<int>& nums,vector<int>&path,vector<bool>&used) {
        if (path.size() == nums.size()) {
            res.push_back(path);
            return ;
        }
        for (int i = 0; i < nums.size(); i ++) {
            if (used[i] == true) continue;
            path.push_back(nums[i]);
            used[i] = true;
            trackback(nums, path, used);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        if (nums.size() == 0) return res;
        dfs(nums);
        return res;
    }
};
（3）复杂度分析

时间复杂度：O(n x n!)
空间复杂度：O(n),其中n为序列的长度。除答案数组以外，递归函数在递归过程中需要为每一层递归函数分配栈空间，所以这里需要额外的空间且该空间取决于递归的深度，这里可知递归调用深度为 O(n)。

2.LCR 083. 全排列

（1）思路
（2）代码
class Solution {
public:
vector<vector<int>> res;
    void process(vector<int>& nums) {
        vector<int> path;
        vector<bool> used(nums.size(),false);
        dfs(used,path,nums);

    }
    void dfs(vector<bool>& used,vector<int> &path,vector<int>& nums) {
        if (path.size() == nums.size())
        {

            res.push_back(path);
            return;
        }
        for (int i = 0; i < nums.size(); i++) {
            if (used[i]) continue;
            path.push_back(nums[i]);
            used[i] = true;
            dfs(used,path,nums);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        if (nums.size() == 0) return res;
        sort(nums.begin(),nums.end());
        process(nums);

        return res;
    }
};
（3）复杂度分析

时间复杂度：O(n x n!)
空间复杂度：O(n)

3.46.全排列2

（1）思路

（2）代码

class Solution {
public:
vector<vector<int>> res;
vector<int> path;
    void process(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        trackback(nums,used);
        
    }
    void trackback(vector<int>& nums,vector<bool>& used) {
        if (path.size() == nums.size()) {
            res.push_back(path); 
            return; 
        }
        for (int i = 0; i < nums.size(); i ++) {
            if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) continue;
            if (used[i] == false) {
            path.push_back(nums[i]);
            used[i] = true;
            trackback(nums, used);
            path.pop_back();
            used[i] = false;
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        if (nums.size() == 0) return res;
        sort(nums.begin(),nums.end());
        process(nums);
        return res;
    }
};

（3）复杂度分析

// 时间复杂度: 最差情况所有元素都是唯一的。复杂度和全排列1都是 O(n! * n) 对于 n 个元素一共有 n! 中排列方案。而对于每一个答案，我们需要 O(n) 去复制最终放到 result 数组
// 空间复杂度: O(n) 回溯树的深度取决于我们有多少个元素

（二）组合

1.77.组合

（1）思路

前序位置，每个节点的值都是一个子集。

（2）代码

class Solution {
public:
vector<vector<int>> res;
vector<int> path;
    void trackback(int n,int k,int start) {
        if (path.size() == k) {
            res.push_back(vector<int>(path.begin(), path.end()));
            return ;
        }
        for (int i = start;i <= n; i++) {
            path.push_back(i);
            trackback(n, k, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        if(n == 0) return res;
        trackback(n,k,1);
        return res;
    }
};

2.39.组合总和

（1）思路

（2）代码

class Solution {
public:
vector<vector<int>>res;
vector<int> path;
    void backtrack(vector<int>& candidates,int target,int sum,int start) {
        if (sum == target) {
            res.push_back(path);
            return ;
        }
        for (int i = start; i < candidates.size() && sum + candidates[i] <= target; i++) {
        
            
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtrack(candidates, target, sum,i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        if (candidates.size() == 0) return res;
        sort(candidates.begin(), candidates.end()); // 需要排序
        backtrack(candidates,target,0,0);    
        return res;
    }

};

（3）复杂度分析

时间复杂度: O(n * 2^n)，注意这只是复杂度的上界，因为剪枝的存在，真实的时间复杂度远小于此
空间复杂度: O(target)

3.40.组合总和2

（1）思路

（2）代码

class Solution {
public:
vector<vector<int>> res;
vector<int> path;

    void trackback(vector<int>& candidates, int target,int sum,int start,vector<bool> &used) {
        if (sum == target) {res.push_back(path);return;}
        for (int i = start; i < candidates.size() && sum + candidates[i] <= target; i++) {
            if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) continue;
        
            sum += candidates[i];
            used[i] = true;
            path.push_back(candidates[i]);
            trackback(candidates, target, sum, i + 1,used);
            used[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        if (candidates.size() == 0) return res;
        vector<bool> used(candidates.size(), false);
        sort(candidates.begin(), candidates.end());
        trackback(candidates,target,0,0,used);
        return res;
    }
};

（3）复杂度分析

时间复杂度: O(n * 2^n)，注意这只是复杂度的上界，因为剪枝的存在，真实的时间复杂度远小于此
空间复杂度: O(n)

4.216.组合总和3

（1）思路

（2）代码

class Solution {
public:
vector<vector<int>> res;
vector<int> path;
    void trackback(int k,int n,int index,int sum) {
        if (path.size() == k) {
            if (sum == n) res.push_back(path);
            return ;
        }
        for (int i = index; i <= 9 -(k - path.size()) + 1; i++) {
            sum += i;
            path.push_back(i);
            if (sum > n) {
                sum -= i;
                path.pop_back();
                return ;
            }
            trackback(k, n, i + 1,sum);
            path.pop_back();
            sum -= i;
        }
    }
    vector<vector<int>> combinationSum3(int k, int n) {
        if (n == 0) return res;
        trackback(k,n,1,0);
        return res;
    }
};

5.17.电话号码的字母组合

（1）思路

（2）代码

class Solution {
public:
const string letterMap[10] = {
        "", // 0
        "", // 1
        "abc", // 2
        "def", // 3
        "ghi", // 4
        "jkl", // 5
        "mno", // 6
        "pqrs", // 7
        "tuv", // 8
        "wxyz", // 9
};
vector<string> result;
string s;
    void backtracking(const string  &digits,int index) {
        if (index == digits.size()) {
            result.push_back(s);
            return ;
        }
        int digit = digits[index] - '0';
        string letters = letterMap[digit];
        for (int i = 0; i < letters.size(); i++) {
            s.push_back(letters[i]);

            backtracking(digits, index + 1);
            s.pop_back();
        }
    }

    vector<string> letterCombinations(string digits) {
        s.clear();
        result.clear();
        if (digits.size() == 0) {
            return result;
        }
        backtracking(digits, 0);
        return result;
    }
};

（3）复杂度分析

时间复杂度: O(3^m * 4^n)，其中 m 是对应四个字母的数字个数，n 是对应三个字母的数字个数
空间复杂度: O(3^m * 4^n)

（三）子集

1.78.子集

（1）思路

还是以 nums = [1,2,3] 为例，刚才让你求所有子集，就是把所有节点的值都收集起来；现在你只需要把第 2 层（根节点视为第 0 层）的节点收集起来，就是大小为 2 的所有组合。

（2）代码

class Solution {
public:
vector<vector<int>> res;
vector<int> path;
    vector<vector<int>> subsets(vector<int>& nums) {
        backtrack(nums,0);
        return res;
    }
    void backtrack(vector<int>& nums,int start) {
        res.push_back(path);

        for (int i = start; i < nums.size(); i ++) {
            path.push_back(nums[i]);
            backtrack(nums, i + 1);
            path.pop_back();
        }
    }
};

（3）复杂度分析

时间复杂度：O(n×2n)。一共 2n个状态，每种状态需要 O(n)的时间来构造子集。
空间复杂度：O(n)，临时数组 t 的空间代价是 O(n），递归时栈空间的代价为 O(n)。

class Solution {
public:
vector<vector<int>> res;
vector<int> path;
    void trackback(int n,int k,int start) {
        if (path.size() == k) {
            res.push_back(vector<int>(path.begin(), path.end()));
            return ;
        }
        for (int i = start;i <= n; i++) {
            path.push_back(i);
            trackback(n, k, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> combine(int n, int k) {
        if(n == 0) return res;
        trackback(n,k,1);
        return res;
    }
};

2.131.分割回文串

（1）思路

切割问题，有不同的切割方式
判断回文

（2）代码

class Solution {
public:
vector<vector<string>> res;
vector<string> path;
    void backtrack(string s,int start) {
        if (start >= s.size()) { // 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
            res.push_back(path);
            return ;
        }   
        for (int i = start; i < s.size(); i ++) {
            if (isVaild(s,start,i)) {
                string str = s.substr(start,i - start + 1);
                path.push_back(str);
            }
            else {
                continue;
            }
            backtrack(s, i + 1); // 寻找i+1为起始位置的子串
            path.pop_back();
        }
      
    }
    bool isVaild(const string& s, int start, int end) {
     for (int i = start, j = end; i < j; i++, j--) {
         if (s[i] != s[j]) {
             return false;
         }
     }
     return true;
 }
    vector<vector<string>> partition(string s) {
        if (s.size() == 0) return res;
        backtrack(s,0);
        return res;
    }
};

（3）复杂度分析

时间复杂度: O(n * 2^n)
空间复杂度: O(n^2)

class Solution {
public: 
vector<string> res;
string path;
    void backtrack(string &s,int start,int pointSum) {
        if (pointSum == 3) {
            if (inVaild(s,start, s.size() - 1)) {
                res.push_back(s);
            }
            return ;
        }
        for (int i = start;i < s.size(); i++) {
            if (inVaild(s,start,i)) {
                 s.insert(s.begin() + i + 1 , '.');
                 pointSum ++;
                 backtrack(s, i + 2, pointSum);
                 pointSum --;
                 s.erase(s.begin() + i + 1);      
            }
            else  break;
        }
    }
    bool inVaild(const string & s,int start,int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) {
            return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') {
            return false;
            }
            num = num * 10 + (s[i] - '0');
            if (num > 255)
                return false;
            }   
       return true;
    }   
    vector<string> restoreIpAddresses(string s) {
        if (s.size() == 0) return res;
        backtrack(s,0,0);
        return res;
    }
};

3.93.复原IP地址

（1）思路

（2）代码

class Solution {
public: 
vector<string> res;
string path;
    void backtrack(string &s,int start,int pointSum) {
        if (pointSum == 3) {
            if (inVaild(s,start, s.size() - 1)) {
                res.push_back(s);
            }
            return ;
        }
        for (int i = start;i < s.size(); i++) {
            if (inVaild(s,start,i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
                 s.insert(s.begin() + i + 1 , '.'); // 在i的后面插入一个逗点
                 pointSum ++;
                 backtrack(s, i + 2, pointSum); //  插入逗点之后下一个子串的起始位置为i+2
                 pointSum --;
                 s.erase(s.begin() + i + 1);    //回溯删掉逗点
            }
            else  break;
        }
    }
    bool inVaild(const string & s,int start,int end) {
        if (start > end) {
            return false;
        }
        if (s[start] == '0' && start != end) {
            return false;
        }
        int num = 0;
        for (int i = start; i <= end; i++) {
            if (s[i] > '9' || s[i] < '0') {
            return false;
            }
            num = num * 10 + (s[i] - '0');
            if (num > 255)
                return false;
            }   
       return true;
    }   
    vector<string> restoreIpAddresses(string s) {
        if (s.size() == 0) return res;
        backtrack(s,0,0);
        return res;
    }
};

（3）复杂度分析

  • 时间复杂度: O(3^4)，IP地址最多包含4个数字，每个数字最多有3种可能的分割方式，则搜索树的最大深度为4，每个节点最多有3个子节点。
  • 空间复杂度: O(n)

4.90.子集 II

（1）思路

（2）代码

class Solution {
public:
vector<vector<int>> res;
vector<int> path;
 void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
     res.push_back(path);
     for (int i = startIndex; i < nums.size(); i++) {
          if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
                continue;
            }
            path.push_back(nums[i]);
            used[i] = true;
            backtracking(nums, i + 1, used);
            used[i] = false;
            path.pop_back();
     }
}
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        res.clear();
        path.clear();
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end()); // 去重需要排序
        backtracking(nums, 0, used);
        return res;
    }
};

（3）复杂度分析

  • 时间复杂度: O(n * 2^n)
  • 空间复杂度: O(n)

5.491.递增子序列

class Solution {
public:
vector<vector<int>> res;
vector<int> path;
    void backtrack(vector<int>&nums,int start) {
        if (path.size() > 1) {
            res.push_back(path);
    // 注意这里不要加return，因为要取树上的所有节点
        }
        unordered_set<int> uset; // 使用set对本层元素进行去重
        for (int i = start; i < nums.size(); i ++ ) {
            if ((!path.empty() && nums[i] < path.back())
                    || uset.find(nums[i]) != uset.end()) {
                    continue;
            }
            uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
            path.push_back(nums[i]);
            backtrack(nums, i + 1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        if (nums.size() == 0) return res;
        
        backtrack(nums,0);
        return res;
    }
};

（四）N皇后问题、岛屿问题

1.51.N皇后

（1）思路

（2）代码

class Solution {
public:
vector<vector<string>> res;
    vector<vector<string>> solveNQueens(int n) {
        vector<string> board (n,string(n,'.'));
        backtrack(board,0);
        return res;
    }
    void backtrack(vector<string>& board, int row) {
        if (row == board.size()) {
            res.push_back(board);
            return;
        }
        int n = board[row].size();
        for (int col = 0; col < n; col++) {
            if (!isvaild(board,row,col)) {
                continue;
            }
            board[row][col] = 'Q';
             backtrack(board, row + 1);
            // 撤销选择
            board[row][col] = '.';
        }
    }
    bool isvaild(vector<string>& board, int row, int col) {
        int n = board.size();
        for (int i = 0; i <= row; i++) {
            if (board[i][col] == 'Q')
                return false;
        }
        for (int i = row - 1,j = col + 1; i >= 0 && j < n;i --,j ++) { // 左上
            if (board[i][j] == 'Q')
            return false;
        }
        for (int i = row - 1, j = col - 1;i >= 0 && j >= 0; i--, j--) {  // 右上
            if (board[i][j] == 'Q')
            return false;
        }
        return true;
    }
};

（3）复杂度分析

for_everyoung01
关注
专栏目录
PHP Trackback-开源
05-15
- **接收 Trackback**: 虽然描述中没有明确提到，但通常一个完整的 Trackback 实现也会包含接收 Trackback 的功能，使得自己的网站能够接收并处理来自其他网站的 ping。 ### 3. 开源许可证 该 PHP Trackback 类...
Python中的traceback的基本用法（异常处理）
热门推荐
YFater的博客
08-26 8万+
文章目录一.Traceback介绍二.Traceback中的相关函数1.traceback.print_exc 一.Traceback介绍 在日常开发中，我们会做一些基本的异常处理，但是有时候只能打印我们处理的结果或者将异常打印出来，不能直观的知道在哪个文件中的哪一行出错。 def func(num1, num2): try: x = num1 * num2 y = num1 / num2 return x, y except Exceptio
python中traceback获取异常信息
专注于前沿科技解读与实用技巧分享，致力于将复杂技术简单化
12-28 1200
在日常工作中，我们常常会碰到异常，我们想在异常发生的时候，不但能显示异常发生的位置，还能看到异常方法被调用的堆栈信息，在python中怎么实现呢？ 实际上python提供了一个traceback来实现类似功能，这个模块提供了一个标准接口来提取、格式化和打印Python程序的堆栈跟踪。它完全模仿Python解释器打印堆栈跟踪时的行为。当您希望在程序控制下打印堆栈跟踪时，这非常有用。
Python进阶之-traceback详解
最新发布
Summer的博客
04-30 4459
在日常开发中，我们会做一些基本的异常处理，但是有时候只能打印我们处理的结果或者将异常打印出来，不能直观的知道在哪个文件中的哪一行出错。在Python中，traceback是一个用来跟踪异常错误信息的标准库，常用于异常处理和调试。它可以帮助开发者了解异常发生的上下文，并提供关于异常发生处的调用堆栈的信息。在实际开发中，通过使用traceback模块，可以更清晰地看到错误发生的位置及其前后调用关系，从而帮助快速定位并修复问题。
Python Traceback指南：异常代码排错利器
涛哥聊Python
12-12 1485
try:# 一些可能引发错误的代码# 创建自定义TracebackTraceback在Python开发中扮演着关键角色，为开发者提供了错误和异常的详尽信息。它是调试代码、定位问题的有力工具。通过Traceback，可以快速了解错误的类型、发生位置以及函数调用堆栈，有助于解决bug和改进代码质量。其信息丰富性提供了多方面的帮助。文件路径和行号提供了错误的具体定位，让开发者能够迅速跟踪问题所在。同时，Traceback呈现了函数间的调用路径，帮助理解代码的执行过程。
Python入门进阶篇 No.5 —— with 上下文管理_trackback 模块
成长的Offer
01-17 760
Python入门进阶篇 No.5 —— with 上下文管理_trackback 模块 文章目录Python入门进阶篇 No.5 —— with 上下文管理_trackback 模块一、with 上下文管理二、trackback 模块三、自定义异常类总结 前生篇：return 语句和异常处理问题_常见异常的解决_常见异常汇总 基础篇：小白不看都能懂 —— Python之真功夫系列（全章） 一、with 上下文管理 finally 块由于是否发生异常都会执行，通常我们放释放资源的代码。其实，我们可以通
TrackBack user guide
11-01
#### 五、TrackBack命令行工具 **命令行选项：** - 提供了一系列命令行参数，允许用户通过命令行控制TrackBack的行为。 - 支持执行备份任务、查询历史记录等功能。 综上所述，TrackBack是一款功能强大且易于使用...
Trackback for DSpace-开源
05-13
标题 "Trackback for DSpace-开源" 指涉的是一个专门为开源数字存储系统DSpace添加Trackback功能的项目。Trackback是一种Web服务协议，它允许网站之间建立链接和通信，使得用户可以在自己的博客或其他网站上发布对...
回溯算法装载问题.doc
10-07
五、知识点总结 * 回溯算法的基本思想：回溯算法是一种搜索算法，通过递归调用函数来搜索所有可能的解。 * 回溯算法的应用：回溯算法广泛应用于解决组合优化问题，例如装载问题、旅行商问题、排列问题等。 * Java ...
Trackback2ElggRiver-开源
05-15
Elgg是一个社交网络CMS。 该项目旨在构建和推进mod的开发，以使用户能够通过使用引用从外部站点将项目安全地添加到Elgg活动河中。
python入门知识（九）：异常处理+程序调试
qq_32419125的博客
10-09 562
文章目录一、二、try...except（一）try...except基本结构（二）try...多个except结构（三）try...except...else结构（四）try...except...finally结构三、常见异常汇总和说明（一）return语句和异常处理问题（二）常见异常的解决1.SyntaxError：语法错误2.NameError：尝试访问一个没有申明的变量3.ZeroDivisionError：除数为0的错误4.ValueError：数值错误5.TypeError：类型错误6.Att
Python traceback模块：获取异常信息
Itmastergo的博客
03-07 1172
除了使用 sys.exc_info() 方法获取更多的异常信息之外，还可以使用 traceback 模块，该模块可以用来查看异常的传播轨迹，追踪异常触发的源头。
后台快速开发框架搭建记录（5）——异常处理
TIANQIcode
09-23 250
一、创建自定义异常类 捕获自定义异常时，使用此类创建新的异常对象。 package com.tianqicode.myquickframe.common.exception; /** * @author wangtianqi * @create 2020-09-23 9:31 */ public class TqException extends RuntimeException { private String msg; private int code = 500;
Python之Traceback
why404
11-10 391
# coding=utf-8 # 测试trackback模块的使用 import traceback #######将异常信息输出到指定的文件中####### try: print('1******') a = 1/0 except: with open('c:/a.txt','a') as f: traceback.print_exc(file=f) ...
TrackBack是什么？如何使用TrackBack？
Devaz的空间
12-01 2万+
什么是TrackBack? 　　简单说来，TrackBack被设计用来提供一种方法以实现网站之间的互相通告：它是一种方法，能让甲对乙说（甲、乙指两个人，下同），“这篇文章可能是你感兴趣的”。要实现这个动作，甲向乙发送一个TrackBack ping即可。 　　TrackBack ping:在这种情况下，一个ping就是一条从一个web服务器发送到另一个服务器的短消息(a small message
python优雅编程_Python——traceback的优雅处理
weixin_39628256的博客
11-26 681
Python——traceback的优雅处理刚接触Python的时候，简单的异常处理已经可以帮助我们解决大多数问题；但是随着逐渐地深入，我们会发现有很多情况下简单的异常处理已经无法解决问题了，如下代码，单纯的打印异常所能提供的信息会非常有限。#!/usr/bin/env python3def func():raise Exception("-- func exception --")def mai...
python没有错误但是不显示结果_python出错时提示消息解读
weixin_39949584的博客
11-23 1514
写 Python 代码的时候,当代码中出现错误，会在输出的时候打印 Traceback 错误信息，很多初学者看到那一堆错误信息，往往都会处于懵逼状态，脑中总会冒出一句，这都是些啥玩意。如果你是第一次看到它，也许你不知道它在告诉你什么。虽然 Python 的 Traceback 提示信息看着挺复杂，但是里面丰富的信息，可以帮助你诊断和修复代码中引发异常的原因，以及定位到具体哪个文件的哪行代码出现...
Python学习笔记 - 探索Traceback回溯机制
Mr数据杨
05-03 1万+
在Python编程的学习和实践中，掌握Traceback（回溯）机制是提高调试能力的关键一步。通过本教程的学习，我们系统地了解了Python中回溯的基本概念、常见的回溯类型以及如何捕获和记录这些回溯信息。Traceback信息是Python调试的重要工具，它不仅可以帮助新手程序员更好地理解和解决编程中的错误，也为有经验的开发者提供了强有力的支持，特别是在处理复杂项目或维护生产环境时。通过记录和分析Traceback信息，我们能够更加高效地追踪问题，优化代码质量，并最终提升整个系统的可靠性。
python traceback安装_python之traceback
weixin_39883705的博客
11-29 588
traceback 模块允许你在程序里打印异常的跟踪返回 (Traceback)信息1.1 traceback.print_exc()File: traceback-example-1.py# note! importing the traceback module messes up the# exception state, so you better do that here and not...
ModuleNotFoundError: No module named 'trackback'
09-06
在这个例子中，出现了一个ModuleNotFoundError: No module named 'trackback'的错误。这是因为在代码中尝试导入了一个名为'trackback'的模块，但是系统找不到这个模块。 如果想要定位到上一次出错的地方，可以使用...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值