明明的博客

基本格式：key = '待匹配字符串'p = '匹配规则'pattern = re.compile(p)res = pattern.findall(key) #匹配结果 findall结果存在list里，此外还有research默认贪婪方式匹配，设置懒惰方式：?.:任意字符[0-9]:0-9[a-z]:a-z[A-Z]:A-Z\d:[0-9]\D:非数字\w:[a-z0-9A-Z_]\W:除开数字、字母、下划线之外的字符+:匹配1次或多次*:匹配0次或多次{m, n}:匹配

文章目录多线程一、创建线程二、线程执行带有参数的任务三、主线程与子线程的结束顺序四、线程之间的执行是无序的，是由CPU调度决定的五、进程和线程总结多线程线程是程序执行的最小单位，一个进程中最少有一个线程，线程本身并不拥有系统资源，但它可与同属一个进程的其他线程共享进程所拥有的全部资源。通过多线程可实现多任务，还节省资源。一、创建线程导入线程模块：import threading创建线程对象：线程对象 = threading.Thread(target=任务名)启动线程：线程对象.star

文章目录多任务多进程注意事项总结多任务概念：同一时间执行多个任务作用：充分利用CPU资源，提高程序执行效率表现形式：并发（操作系统交替执行多个任务，同一时间只有一个任务在执行）、并行（操作系统给每个CPU安排一个任务，这些任务是真正意义上的同时执行）在Python中可以使用多进程和多线程来实现多任务多进程进程：操作系统进行资源分配的基本单位。简单来说，一个运行起来的程序就是一个进程多进程实现多任务的步骤1）导包：import multiprocess2）创建进程对象：进程对象 =.

ord()把ASCII码转成对应的数字，chr()把数字转成对应的ASCII码s1 = 'a's2 = 99print(ord(s1))print(chr(s2))输出结果分别是97和c

f = open("E:\Python_Project\test.txt")错误1：'unicodeescape' codec can't decode bytes in position 14: truncated \uXXXX escape解决方法：在路径前面加上r就好， 因为路径中的\ 是转义字符f = open(r"E:\Python_Project\test.txt")错误2：with open("E:\Python_Project\test.txt") as f:

题目地址：https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array/我的解答：class Solution: def findDisappearedNumbers(self, nums: List[int]) -> List[int]: if not nums: return [] n = len(nums) res = [] nums

首先要下载相应的模块win+R 打开cmd，执行 pip install PyMySQL #连接mysql所需要的模块 pip install pymssql #连接sql server所需要的模块然后你可以在环境变量中找到Python的路径，在…（你的Python路径）\Python\Lib\site-packages里可以找到以上两个包2.接着，就可以在ide中引入需要的模块，进行数据库连接了#连接mysqlimport pymysqlconn = pymysql.conne.

题目地址：https://leetcode-cn.com/problems/invert-binary-tree/看了百十来题，我仍然是一看就会，一做就废的菜鸡（有时候看都看不懂# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Nonec

题目地址：https://leetcode-cn.com/problems/house-robber/动态规划，即使这么简单我还是写不对注意：只要不进两个连续的房屋就不会报警，但是可以跨好几个房屋，只要它们屋里的现金相加结果最大dp[n]表示前n个房屋能偷到的最大现金，那dp[n + 1] 就等于 dp[n - 1] + 第n + 1这个房屋里的现金num，和dp[n]这两个数中的最大值，即：dp[n + 1] = max(dp[n], dp[n- 1] + num)class Solution:

题目地址：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/注意：如果两个链表没有交点，返回 null.在返回结果后，两个链表仍须保持原有的结构。可假定整个链表结构中没有循环。程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。解法1：# Definition for singly-linked list.# class ListNode:# def __init__(self, x)

题目地址：https://leetcode-cn.com/problems/combination-sum-ii/class Solution: def combinationSum2(self, candidates: List[int], target: int) -> List[List[int]]: if not candidates: return [] n = len(candidates) candidates.sort()

题目地址：https://leetcode-cn.com/problems/combination-sum/提示： 1 <= candidates.length <= 30 1 <= candidates[i] <= 200 candidate中的每个元素都是独一无二的。 1 <= target <= 500class Solution: def combinationSum(self, candidates: List[int], target: i

题目地址：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/labuladong二分法笔记之前看负雪明烛推荐过labuladong，我就找了他的算法小抄（是叫这名儿吧？）来看，也关注了公众号。觉得这篇写得很好，我读完之后的笔记如下：一般要求时间复杂度为O(logN)的题目就要考虑二分法。二分法主要是解决在有序数组中搜索一个值、搜索左边界/右边界的问题。1.搜索一个值的

题目地址：https://leetcode-cn.com/problems/linked-list-cycle/时间复杂度和空间复杂度都是O(n)：# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = Noneclass Solution: def hasCycle(self, head:

题目地址：https://leetcode-cn.com/problems/search-in-rotated-sorted-array/class Solution: def search(self, nums: List[int], target: int) -> int: if not nums: return -1 l, r = 0, len(nums) - 1 while l < r: mid = (

题目地址：LeetCode#31.下一个排列class Solution: def nextPermutation(self, nums: List[int]) -> None: """ Do not return anything, modify nums in-place instead. """ if len(nums) < 2: return nums for i in range(len(nu

我要什么时候才能达到那种看一个题就知道用什么方法、套什么模板的境界呢class Solution: def generateParenthesis(self, n: int) -> List[str]: #if n == 0: return [] res = [] path = "" self.dfs(res, n, n, path) return res def dfs(self, res, lef.

我做不出来这就是#112的升级，但我就是不会转弯呀看别人题解，看半天算是懂了，尤其是tmp + [root.val]这个写法# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def pat.

1、递归#class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def hasPathSum(self, root: TreeNode, sum: int) -> bool: if not root: return False sum -= root.val if not root.left and not ro.

BFS比DFS合适，因为BFS遇到第一个叶子结点就可直接返回结果，而DFS要遍历整棵树我再写一遍递归和BFS：1、递归# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def minDep.

这个题对我来说好绕啊，我懂思路但是递归真难理解。。。看题解看半天还是有点懵，我晕！# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def isBalanced(self, root: Tr.

一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。二叉搜索树：任一节点的值都大于其左子树的节点值，都小于其右子树的节点值。把链表转成数组，就和前一题一样辽：# Definition for singly-linked list.# class ListNode:# def __init__(self, x):# self.val = x# self.next = None# Definition for a bin

BFS，令中间位置右边元素（如果数组长度为偶数；数组长度为奇数则就是中间位置元素）作为根节点# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def sortedArrayToBST(self.

这就是#102变个形式输出# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def levelOrderBottom(self, root: TreeNode) -> List[List.

和#105 一个解法：# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def buildTree(self, inorder: List[int], postorder: List[int].

前序的第一个节点就是根节点，再去中序里面找到根节点的索引，那根节点之前的部分就是左子树，根节点后部分就是右子树找索引用哈希表，降低时间复杂度# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: .

这个题目是#102变了个输出形式而已，巩固一下# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def zigzagLevelOrder(self, root: TreeNode) ->.

我用的递归，以为没问题，结果提交之后没通过！仔细阅读才发现，题目我都没完全理解：节点的左子树只包含小于当前节点的数。节点的右子树只包含大于当前节点的数。比如：[10,5,15,null,null,6,20] 这个测试用例结果应该返回false，因为右子树中的左子节点6小于根节点10我好傻呀以下是看了题解之后再写的正解：1、递归# Definition for a binary tree node.# class TreeNode:# def __init__(self, x.

对题解区的各解法做一个总结：1、递归# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = None#前序（根左右）class Solution: def inorderTraversal(self, root: TreeNode) .

BFS:# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def levelOrder(self, root: TreeNode) -> List[List[int]]: .

重点是你的算法应该具有线性时间复杂度。这类题用位运算，异或（相同为0，不同为1，满足交换律和结合律）1 ^ 1 = 00 ^ 0 = 01 ^ 0 = 1Class Solutions: def singleNumber(self, nums: List[int]) -> int: res = nums[0] for i in range(len(nums)): res ^= nums[i] return resget新知识...

递归（dfs）：# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def maxDepth(self, root: TreeNode) -> int: if not ro.

两种解法，递归（dfs）和队列（广度）递归，看了官方题解：# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def isSymmetric(self, root: TreeNode) -&g.

这类题非常陌生，不过有好多个类似题可以用来反复练习，从这开始# Definition for a binary tree node.# class TreeNode:# def __init__(self, x):# self.val = x# self.left = None# self.right = Noneclass Solution: def isSameTree(self, p: TreeNode, q: Tree.

进阶：你可以优化你的算法到 O(k) 空间复杂度吗？class Solution: def getRow(self, rowIndex: int) -> List[int]: if rowIndex == 0:return [1] L = [1] L1 = [0] + L L2 = L + [0] #temp = [] n = 0 while(n..

这个题目，在廖雪峰的Python教程里我看到过，是生成器那一节，我记得当时我还写了点笔记，但是这次虽然做出来了可是不是用生成器，还花了好一会儿时间！class Solution: def generate(self, numRows: int) -> List[List[int]]: if numRows == 0:return [] res = [[1]] if numRows == 1:return res l = [0].

Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。str = 'hello'print(str.zfill(10))#输出 00000helloclass Solution: def addBinary(self, a: str, b: str) -> str: n = max(len(a),len(b)) a = a.zfill(n) b = b.zfill(n) c = 0 #c.

递归、动态规划、斐波那契数列公式三种解递归容易超时、直接动态规划空间复杂度为O（n），优化一下可以为O（1）：class Solution: def climbStairs(self, n: int) -> int: if n == 1:return 1 if n == 2:return 2 a,b,res = 1,2,0 for i in range(3,n+1): res = a+b .

二分法：class Solution: def mySqrt(self, x: int) -> int: if x == 0:return 0 l,r = 0,x while(l<=r): mid = (l+r) // 2 if mid*mid == x: return mid elif mid*mid < x: .

我思路是合并后排序，以下是我的解法，通过了但其实是不符合题目要求的，因为题目说了只能在nums1本身做修改class Solution: def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None: """ Do not return anything, modify nums1 in-place instead. """ .