Gethin

期权交易进阶指南2

Gethin — Mon, 11 Aug 2025 11:52:39 +0800

期权交易进阶指南2

期权交易作为一种高级金融工具，不仅为投资者提供了灵活的风险管理和收益增强手段，还能够通过复杂的策略组合实现精准的市场定位。对于期权交易专家而言，深入理解市场动态、灵活运用高级策略以及精准的风险管理是提升交易绩效的关键。本文将探讨期权交易的高级策略、波动率交易、事件驱动策略以及算法交易，帮助期权交易者达到专家级别。

1. 波动率交易

波动率概述 ：波动率是衡量标的资产价格变动幅度的指标，分为历史波动率和隐含波动率。期权交易者可以通过交易波动率来捕捉市场情绪变化和预期波动。

波动率交易策略 ：

卖出波动率 ：当隐含波动率高于历史波动率且预期市场波动将减小时，卖出期权以赚取时间价值。
策略：卖出跨式组合（同时卖出相同行权价、相同到期日的认购期权和认沽期权）。
买入波动率 ：当隐含波动率低于历史波动率且预期市场将出现大幅波动时，买入期权以捕捉潜在的高收益。
策略：买入跨式组合（同时买入相同行权价、相同到期日的认购期权和认沽期权）。

波动率曲面 ：通过分析不同行权价和到期日的期权隐含波动率，构建波动率曲面来识别市场对不同价格水平和时间段的波动预期，从而发现交易机会。

2. 事件驱动策略

事件驱动概述 ：事件驱动策略利用公司特定事件（如财报发布、并购公告等）带来的市场波动进行交易。

策略构建 ：

财报发布前策略 ：在财报发布前，市场通常预期波动增加，可以通过买入跨式组合来捕捉波动。
风险管理 ：通过动态对冲调整Delta中性，减少方向性风险。
并购事件策略 ：在并购公告前后，目标公司和收购公司的股价通常会出现大幅波动。
策略：买入目标公司的认购期权或认沽期权，根据并购成功概率和预期股价变动调整仓位。

3. 高级组合策略

铁鹰策略 ：结合牛市价差和熊市价差，形成有限风险和收益的策略。

构建方法 ：买入较低行权价的认沽期权，卖出较高行权价的认沽期权，同时卖出较低行权价的认购期权，买入较高行权价的认购期权。
优点：适合预期市场波动在一定范围内的行情。

日历价差策略 ：利用不同到期日期权的时间价值差异进行交易。

构建方法 ：买入较远月份的期权，卖出较近月份的期权。
优点：适合预期市场短期内波动较小，长期内波动较大的行情。

4. 算法交易

算法交易概述 ：算法交易通过计算机程序自动执行交易策略，提高交易效率和准确性。

期权算法交易策略 ：

高频交易 ：利用高速交易系统捕捉市场微小的价格差异进行高频交易。
策略：市场微观结构分析，订单簿动态监测。
统计套利 ：通过统计分析发现市场中的套利机会并进行交易。
策略：配对交易，波动率套利。

5. 风险管理

风险价值（VaR） ：通过计算一定时间内投资组合可能面临的最大损失来评估风险。

应用：设定止损点，控制单笔交易和整体组合的风险。

情景分析 ：模拟不同市场情景对投资组合的影响，制定相应的应对策略。

应用：极端市场条件下的压力测试，调整策略以应对潜在风险。

6. 案例分析

案例一：波动率交易

期权交易进阶指南1

Gethin — Mon, 11 Aug 2025 10:52:39 +0800

期权交易进阶指南1

期权交易作为一种金融衍生品工具，不仅可以帮助投资者对冲风险，还可以实现杠杆收益和灵活的资产配置。对于已经掌握期权基本概念和基础策略的投资者来说，深入了解期权的定价机制、组合策略以及高级风险管理技巧是提升交易水平的关键。本文将探讨期权交易的进阶内容，帮助投资者更好地利用期权进行投资。

1. 期权定价模型

Black-Scholes模型 ：这是最著名的期权定价模型之一，用于计算欧式期权的理论价格。模型考虑了五个主要因素：标的资产价格、行权价格、剩余期限、无风险利率和波动率。

希腊字母 ：用于衡量期权价格对不同影响因素的敏感度。

Delta ：期权价格对标的资产价格变化的敏感度。
Gamma ：Delta对标的资产价格变化的敏感度。
Theta ：期权价格对时间变化的敏感度。
Vega ：期权价格对波动率变化的敏感度。
Rho ：期权价格对无风险利率变化的敏感度。

2. 高级组合策略

领口策略 ：结合买入认沽期权和卖出认购期权，降低保险成本的同时保留上行收益。

构建方法 ：持有标的股票，买入平值或轻度虚值的认沽期权，同时卖出更高行权价的认购期权。
优点：成本较低，适合长期看好标的股票但担心短期波动的投资者。

蝶式策略 ：通过买入和卖出不同行权价的期权，形成有限风险和收益的策略。

构建方法 ：买入一份较低行权价的认购期权和一份较高行权价的认购期权，同时卖出两份中间行权价的认购期权。
优点：适合预期市场波动较小的行情，可以实现低风险、低成本的投资。

跨式策略和勒式策略 ：通过同时买入认购期权和认沽期权，捕捉市场大幅波动。

构建方法 ：买入相同到期日、相同行权价的认购期权和认沽期权（跨式策略）；买入相同到期日、不同行权价的认购期权和认沽期权（勒式策略）。
优点：适合预期市场将出现大幅波动但方向不明的行情。

3. 高级风险管理技巧

动态对冲 ：通过不断调整期权和标的资产的持仓比例，以保持Delta中性，从而降低市场波动对组合的影响。

方法：根据市场变化，定期调整Delta值，确保组合对标的资产价格变化不敏感。

波动率交易 ：利用期权隐含波动率与历史波动率之间的差异进行交易。

方法：买入隐含波动率低于历史波动率的期权，卖出隐含波动率高于历史波动率的期权。

保证金管理 ：合理管理期权卖方的保证金，避免因保证金不足导致的强行平仓。

方法：根据市场波动和持仓情况，及时补充保证金或调整仓位。

4. 实战案例分析

案例一：领口策略应用

背景：投资者持有大量股票，担心短期市场波动影响收益。
策略：买入平值认沽期权，同时卖出虚值认购期权，构建领口策略。
效果：在市场小幅下跌时，认沽期权提供保护；在市场上涨时，认购期权限制收益上限，但整体成本较低。

案例二：蝶式策略应用

背景：市场波动较小，投资者预期短期内不会有大幅波动。
策略：买入较低行权价的认购期权和较高行权价的认购期权，同时卖出两份中间行权价的认购期权，构建蝶式策略。
效果：在市场波动较小时，策略实现低风险、低成本收益。

结语

期权交易进阶涉及复杂的定价模型、高级组合策略和风险管理技巧。投资者需要不断学习和实践，通过深入理解市场动态和灵活运用各种策略，才能在期权交易中取得更好的效果。同时，风险管理始终是期权交易中不可忽视的重要环节，合理控制风险是实现长期稳定收益的关键。

期权交易入门指南1

Gethin — Sun, 10 Aug 2025 10:52:39 +0800

期权交易入门指南1

期权交易是一种金融衍生品交易方式，它赋予持有者在特定时间内以特定价格买入或卖出某种资产的权利，但不是义务。对于刚接触期权交易的投资者来说，了解期权的基本概念、交易策略和风险管理是非常重要的。本文将简要介绍期权交易的基础知识，帮助新手投资者快速入门。

1. 期权基本概念

期权定义 ：期权是一种合约，给予买方在未来某个时间以特定价格买入或卖出标的资产的权利，但不是义务。

期权类型 ：

认购期权（Call Option） ：赋予买方在到期日前以约定价格买入标的资产的权利。
认沽期权（Put Option） ：赋予买方在到期日前以约定价格卖出标的资产的权利。

期权要素 ：

行权价格（Strike Price） ：期权合约中约定的买入或卖出标的资产的价格。
到期日（Expiration Date） ：期权合约的最后有效日期。
合约单位 ：每张期权合约对应的标的资产数量。

2. 期权价值构成

内在价值 ：期权立即行权时的收益。例如，认购期权的内在价值是标的资产价格高于行权价的部分，认沽期权的内在价值是行权价高于标的资产价格的部分。

时间价值 ：期权价格中超过内在价值的部分，反映了期权到期前时间带来的潜在价值。

3. 期权交易策略

单腿策略 ：

买入认购期权 ：预期标的资产价格上涨，最大损失为权利金，潜在收益无限。
买入认沽期权 ：预期标的资产价格下跌，最大损失为权利金，潜在收益有限。
卖出认购期权 ：预期标的资产价格不涨，收益有限，潜在损失无限。
卖出认沽期权 ：预期标的资产价格不跌，收益有限，潜在损失无限。

组合策略 ：

合成股票策略 ：通过买入认购期权和卖出认沽期权，复制股票多头收益。
跨式策略 ：同时买入认购期权和认沽期权，预期市场大幅波动。
牛市价差策略 ：买入低行权价认购期权，卖出高行权价认购期权，预期市场适度上涨。
熊市价差策略 ：买入高行权价认沽期权，卖出低行权价认沽期权，预期市场适度下跌。

4. 期权风险管理

买方风险管理 ：

价值归零风险 ：期权到期时可能变为虚值，导致权利金全部损失。
高溢价风险 ：虚值期权在临近到期被爆炒的风险。
流动性风险 ：期权合约可能面临没有对手方而无法平仓的风险。
行权交割风险 ：忘记行权的风险和行权后的价格波动风险。

卖方风险管理 ：

保证金风险 ：需要缴纳保证金以保证履约。
巨额亏损风险 ：标的资产价格大幅波动可能导致巨额亏损。
流动性风险 ：与买方相同，可能面临无法平仓的风险。
行权交割风险 ：买方行权后需要准备足够的标的资产或资金。

5. 期权交易实战技巧

选择合适的合约 ：考虑流动性、杠杆性和自身的风险承受能力，选择合适的期权合约进行交易。

剑指Offer（python）

xxxx — Wed, 06 Apr 2022 16:22:27 +0800

数组与矩阵

1. 数组中重复的数字

        
        
        
    
class Solution:
    def findRepeatNumber(self, nums: List[int]) -> int:
        dic ={}
        for num in nums:
            if num not in dic:
                dic[num] = True
            else:
                return num

1. 二维数组中的查找

        
        
        
    
class Solution:
    def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
        if not matrix or not matrix[0]:return False
        col = len(matrix)-1
        row = len(matrix[0])-1
        _i,_j = col, 0
        while _i>=0 and _j<=row:
            if matrix[_i][_j]>target:_i-=1
            elif matrix[_i][_j]<target:_j+=1
            else: return True
        return False

1. 替换空格

        
        
        
    
class Solution:
    def replaceSpace(self, s: str) -> str:
        ans =[]
        for c in s:
            if c == " ":
                ans.append('%20')
            else:   
                ans.append(c)
        return "".join(ans)

1. 顺时针打印矩阵

        
        
        
    
class Solution:
    def spiralOrder(self, matrix:[[int]]) -> [int]:
        if not matrix: return []
        l, r, t, b, res = 0, len(matrix[0]) - 1, 0, len(matrix) - 1, []
        while True:
            for i in range(l, r + 1): res.append(matrix[t][i]) # left to right
            t += 1
            if t > b: break
            for i in range(t, b + 1): res.append(matrix[i][r]) # top to bottom
            r -= 1
            if l > r: break
            for i in range(r, l - 1, -1): res.append(matrix[b][i]) # right to left
            b -= 1
            if t > b: break
            for i in range(b, t - 1, -1): res.append(matrix[i][l]) # bottom to top
            l += 1
            if l > r: break
        return res

1. 第一个只出现一次的字符位置

        
        
        
    
class Solution:
    def firstUniqChar(self, s: str) -> str:
        dic = {}
        for c in s:
            if c in dic:
                dic[c] = False
            else:
                dic[c] = True
        for c,v in dic.items():
            if dic[c]:return c
        return " "

栈队列堆

1. 用两个栈实现队列

        
class CQueue:

    def __init__(self):
        self.l1 = []
        self.l2 = []

    def appendTail(self, value: int) -> None:
        self.l1.append(value)

    def deleteHead(self) -> int:
        if self.l2: return self.l2.pop()
        if not self.l1: return -1
        while self.l1:
            self.l2.append(self.l1.pop())
        return self.l2.pop()

1. 包含 min 函数的栈

        
        
        
    
class MinStack:

    def __init__(self):
        """
        initialize your data structure here.
        """
        self.stack = []
        self.minstack = []

    def push(self, x: int) -> None:
        self.stack.append(x)
        if not self.minstack or x<=self.minstack[-1]:
            self.minstack.append(x)


    def pop(self) -> None:
        if self.stack.pop() ==self.minstack[-1]:
            self.minstack.pop()


    def top(self) -> int:
        return self.stack[-1]

    def min(self) -> int:
        return self.minstack[-1]

1. 栈的压入、弹出序列

        
        
        
    
class Solution:
    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
        stack =[]
        _i =0
        for num in pushed:
            stack.append(num)
            while stack and stack[-1]==popped[_i]:# 循环栈
                stack.pop()
                _i+=1
        return not stack

1. 最小的 K 个数

        
        
        
    
class Solution:
    def getLeastNumbers(self, arr: List[int], k: int) -> List[int]:
        def sort(arr):
            if len(arr)<2:
                return arr
            else:
                pivot = arr[0]
                less = [i for i in arr[1:] if i<=pivot]
                more = [i for i in arr[1:] if i> pivot]
                return sort(less) +[pivot]+ sort(more)
        r =sort(arr)
        return r[:k]

41.1 数据流中的中位数

        
        
        
    
from heapq import *

class MedianFinder:
    def __init__(self):
        self.A = [] # 小顶堆，保存较大的一半
        self.B = [] # 大顶堆，保存较小的一半

    def addNum(self, num: int) -> None:
        if len(self.A) != len(self.B):
            heappush(self.A, num)
            heappush(self.B, -heappop(self.A))
        else:
            heappush(self.B, -num)
            heappush(self.A, -heappop(self.B))

    def findMedian(self) -> float:
        return self.A[0] if len(self.A) != len(self.B) else (self.A[0] - self.B[0]) / 2.0

41.2 字符流中第一个不重复的字符

1. 滑动窗口的最大值

        
        
        
    
class Solution:
    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
        deque = collections.deque()
        res, n = [], len(nums)
        for i, j in zip(range(1 - k, n + 1 - k), range(n)):
            # 删除 deque 中对应的 nums[i-1]
            if i > 0 and deque[0] == nums[i - 1]:
                deque.popleft()
            # 保持 deque 递减
            while deque and deque[-1] < nums[j]:
                deque.pop()
            deque.append(nums[j])
            # 记录窗口最大值
            if i >= 0:
                res.append(deque[0])
        return res

双指针

57.1 和为 S 的两个数字

        
        
        
    
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        # 2 points
        _i,_j =0,len(nums)-1
        # slide point _i,_j
        while _i<_j:
            s = nums[_i]+nums[_j]
            if s>target: _j-=1
            elif s< target: _i+=1
            else:return[nums[_i],nums[_j]]
        return []

57.2 和为 S 的连续正数序列

        
        
        
    
class Solution:
    def findContinuousSequence(self, target: int) -> List[List[int]]:
        _i,_j,s = 1,2,3
        ans = []
        while _i<_j:
            if s ==target:
                #ans.append(list(range(i, j + 1)))
                ans.append([i for i in range(_i,_j+1)])
            if s>=target:
                s-=_i
                _i+=1
            else:
                _j+=1
                s+=_j
        return ans

58.1 翻转单词顺序列

        
        
        
    
class Solution:
    def reverseWords(self, s: str) -> str:
        s = s.strip() # 删除首尾空格
        _i=_j = len(s)-1
        ans = []
        # 退出条件
        while _i>=0:
            # 添加单词
            # 向左移动指针
            while _i>=0 and s[_i]!=' ': _i-=1
            ans.append(s[_i+1:_j+1])
            # _i,_j 指针再次初始化 & 跳过 ' '
            while s[_i] == ' ': _i-=1
            _j =_i
        return " ".join(ans)


        # strs = s.split()
        # re_str = strs[::-1]
        # return " ".join(re_str)

58.2 左旋转字符串

        
class Solution:
    def reverseLeftWords(self, s: str, n: int) -> str:
        return s[n:]+s[:n]

链表

1. 从尾到头打印链表

        
        
        
    
class Solution:
    def reversePrint(self, head: ListNode) -> List[int]:
        ans =[]
        def dfs(cur):
            if not cur: return
            dfs(cur.next)
            ans.append(cur.val)
        dfs(head)
        return ans

18.1 在 O(1) 时间内删除链表节点

        
        
        
    
class Solution:
    def deleteNode(self, head: ListNode, val: int) -> ListNode:
        def dfs(node):
            if not node:
                return node
            node.next = dfs(node.next)
            if node.val == val:
                return node.next
            return node
        return dfs(head)

18.2 删除链表中重复的结点

1. 链表中倒数第 K 个结点

        
        
        
    
class Solution:
    def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
        i =0
        def dfs(cur):
            if not cur:
                return cur
            o = dfs(cur.next)
            nonlocal i
            i+=1
            # cur always regression, when k, return cur as o
            if i ==k: return cur
            return o
        return dfs(head)

1. 链表中环的入口结点

1. 反转链表

        
        
        
    

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        def dfs(cur):
            if not cur or not cur.next:
                return cur 
            o =dfs(cur.next)
            cur.next.next = cur
            cur.next = None
            return o
        return dfs(head)

1. 合并两个排序的链表

        
        
        
    
class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        # if l1 is null return l2
        if not l1:
            return l2
        if not l2:
            return l1
        # ex. 1,2,3 | 1,3,4
        # recurrence (push)
        if l1.val <= l2.val:
            o = self.mergeTwoLists(l1.next,l2)
            #regression (pop) l1.next = o(if l1 is none:l2)
            l1.next = o
            return l1
        else:
            o = self.mergeTwoLists(l1,l2.next)
            l2.next = o
            return l2

1. 复杂链表的复制

        
        
        
    
class Solution:
    def copyRandomList(self, head: 'Node') -> 'Node':
        # use dic to build and copy linklist
        if not head: return None
        dic ={}
        _cur = head
        while _cur:
            dic[_cur] = Node(_cur.val)
            _cur = _cur.next
        _cur = head
        while _cur:
            dic[_cur].next = dic.get(_cur.next)
            dic[_cur].random = dic.get(_cur.random)
            _cur = _cur.next
        return dic[head]

1. 两个链表的第一个公共结点

        
        
        
    
class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        A,B = headA,headB
        while A!=B:
            A = A.next if A else headB
            B = B.next if B else headA
        return A

树

1. 重建二叉树

        
        
        
    
class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        # 0
        if len(preorder)==0 or len(inorder)==0:
            return None
        # 1 build root
        r_val = preorder[0]
        root = TreeNode(r_val)
        # find index
        idx = inorder.index(r_val)
        # build left & right based on b-tree attribute
        root.left = self.buildTree(preorder[1:1+idx],inorder[:idx])
        root.right = self.buildTree(preorder[1+idx:],inorder[idx+1:])
        return root

1. 二叉树的下一个结点

1. 树的子结构

        
        
        
    
class Solution:
    def isSubStructure(self, A: TreeNode, B: TreeNode) -> bool:
        if not A or not B:return False
    
        def dfs(A,B):
            if not B:return True
            if not A:return False
            o_l = dfs(A.left,B.left)
            o_r = dfs(A.right,B.right)
            return A.val==B.val and o_l and o_r
        
        return dfs(A,B) or self.isSubStructure(A.left,B) or self.isSubStructure(A.right,B)

1. 二叉树的镜像

        
        
        
    
class Solution:
    def mirrorTree(self, root: TreeNode) -> TreeNode:
        def dfs(node):
            if node is None:
                return node
            o_l =dfs(node.left)
            o_r =dfs(node.right)
            node.left = o_r
            node.right = o_l
            return node
        return dfs(root)

1. 对称的二叉树

        
        
        
    
class Solution:
    def isSymmetric(self, root: TreeNode) -> bool:
        def dfs(left,right):
            if left is None and right is None: # 1. 
                return True
            if left is None or right is None or left.val != right.val:
                return False
            return dfs(left.left, right.right) and dfs(left.right, right.left)

        return dfs(root.left, root.right) if root else True

32.1 从上往下打印二叉树

        
        
        
    
class Solution:
    def levelOrder(self, root: TreeNode) -> List[int]:
        if not root:return []
        q,ans = [root],[]
        while q:
            node = q.pop(0)
            ans.append(node.val)
            if node.left:
                q.append(node.left)
            if node.right:
                q.append(node.right)
        return ans

32.2 把二叉树打印成多行

        
        
        
    
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:return []
        q =[root]
        ans =[]
        while q:
            tmp =[]
            for _ in range(len(q)):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:q.append(node.left)
                if node.right:q.append(node.right)
            ans.append(tmp)
        return ans

32.3 按之字形顺序打印二叉树

        
        
        
    
class Solution:
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        if not root:return[]
        i,q,ans = 0,[root],[]
        while q:
            tmp = []
            i+=1
            for _ in range(len(q)):
                node = q.pop(0)
                tmp.append(node.val)
                if node.left:
                    q.append(node.left)
                if node.right:
                    q.append(node.right)
            if i%2 ==0: ans.append(list(reversed(tmp)))
            else:ans.append(tmp)
        return ans

1. 二叉搜索树的后序遍历序列

        
        
        
    
class Solution:
    def verifyPostorder(self, postorder: List[int]) -> bool:
        # root right left 单调栈        
        stack,root=[],float('inf')

        #二叉搜索树: rootleft
        for num in reversed(postorder): 
            if root < num: return False

            while stack and stack[-1]>num:
                root = stack.pop()
            # root
            stack.append(num)
        return True

1. 二叉树中和为某一值的路径

        
        
        
    
class Solution:
    def pathSum(self, root: TreeNode, target: int) -> List[List[int]]:
        # def res,path
        res = []
        path =[]
        # 1.root left right
        def dfs(cur,tar):
            if not cur:return
            path.append(cur.val)
            tar -= cur.val
            if tar == 0 and not cur.left and not cur.right:
                res.append(list(path))
            dfs(cur.left,tar)
            dfs(cur.right,tar)
            path.pop()
       
        dfs(root,target)
        return res

1. 二叉搜索树与双向链表

        
        
        
    
class Solution:
    def treeToDoublyList(self, root: 'Node') -> 'Node':
        if not root:return
        def dfs(cur):
            if not cur:
                return
            dfs(cur.left)
            if not self.pre:
                self.head = cur # head
            else:
                self.pre.right =cur
                cur.left = self.pre
            self.pre = cur
            dfs(cur.right)
        self.pre = None
        self.head = None
        dfs(root)
        self.head.left = self.pre
        self.pre.right = self.head
        return self.head

1. 序列化二叉树

        
        
        
    
class Codec:
    def serialize(self, root):
        if not root: return "[]"
        queue = collections.deque()
        queue.append(root)
        res = []
        while queue:
            node = queue.popleft()
            if node:
                res.append(str(node.val))
                queue.append(node.left)
                queue.append(node.right)
            else: res.append("null")
        return '[' + ','.join(res) + ']'

    def deserialize(self, data):
        if data == "[]": return
        vals, i = data[1:-1].split(','), 1
        root = TreeNode(int(vals[0]))
        queue = collections.deque()
        queue.append(root)
        while queue:
            node = queue.popleft()
            if vals[i] != "null":
                node.left = TreeNode(int(vals[i]))
                queue.append(node.left)
            i += 1
            if vals[i] != "null":
                node.right = TreeNode(int(vals[i]))
                queue.append(node.right)
            i += 1
        return root

1. 二叉查找树的第 K 个结点

        
        
        
    
class Solution:
    def kthLargest(self, root: TreeNode, k: int) -> int:
        i,r= 0,0
        def dfs(node):
            if node is None:
                return
            dfs(node.right)
            nonlocal i
            nonlocal r
            i+=1
            if i ==k: r = node.val
            dfs(node.left)
        dfs(root)
        return r

55.1 二叉树的深度

        
        
        
    
class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        def dfs(node):
            if node is None:
                return 0 # deep
            o_l =dfs(node.left)
            o_r =dfs(node.right)
            deep = max(o_l,o_r)+1
            return deep
        return dfs(root)

55.2 平衡二叉树

        
        
        
    
class Solution:
    def isBalanced(self, root: TreeNode) -> bool:
        def dfs(node):
            if node is None:
                return 0
            # value==-1 return -1
            o_l = dfs(node.left)
            if o_l == -1:return -1
            o_r = dfs(node.right)
            if o_r ==-1:return -1
            result = max(o_l,o_r)+1 if abs(o_l - o_r)<=1 else -1
            return result
        r =dfs(root)
        return r!=-1

1. 树中两个节点的最低公共祖先

        
        
        
    
class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        def dfs(node,p,q):
            if node.val > p.val and node.val > q.val:
                return dfs(node.left, p, q)
            if node.val < p.val and node.val < q.val:
                return dfs(node.right, p, q)
            return node
        return dfs(root,p,q)

贪心思想

1. 剪绳子

        
        
        
    
class Solution:
    def cuttingRope(self, n: int) -> int:
        dp =[0]*(n+1)
        max_tmp =0
        dp[2] =1 
        for i in range(2,n+1):
            for j in range(1,i):
                max_tmp = max((i-j)*j,dp[i-j]*j)
                dp[i]=max(dp[i],max_tmp)
        return dp[-1]

1. 股票的最大利润

        
        
        
    
class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        min_profit = float('inf')
        max_profit = 0
        for day_price in prices:
            min_profit = min(day_price,min_profit)
            max_profit = max(day_price-min_profit,max_profit)
        return max_profit

二分查找

1. 旋转数组的最小数字

        
        
        
    
class Solution:
    def minArray(self, numbers: List[int]) -> int:
        l,r =0,len(numbers)-1
        while l<=r:
            mid = (l+r)//2
            if numbers[mid]>numbers[r]:
                l=mid+1
            elif numbers[mid]<numbers[r]:
                r =mid
            else:
                r-=1
        return numbers[l]

1. 数字在排序数组中出现的次数

        
        
        
    
class Solution:
    def search(self, nums: List[int], target: int) -> int:
        
        def find_r(nums,target)->int:
            _l,_r = 0,len(nums)-1
            while _l<=_r:
                m = (_l+_r)//2
                if nums[m] <= target:
                    _l = m+1
                else:
                    _r = m-1
            return _l
        r = find_r(nums,target)
        r_pre = find_r(nums,target-1)
        return  r - r_pre 

分治

1. 数值的整数次方

        
        
        
    
class Solution:
    def myPow(self, x: float, n: int) -> float:
        if n == 0: 
            return 1
        elif n < 0: # 1/x^{-n}
            return 1/self.myPow(x, -n)
        elif n & 1: # odd: x∗x^(n−1)
            return x * self.myPow(x, n - 1)
        else: # even x^2*(n/2)
            return self.myPow(x*x, n // 2)

搜索

1. 矩阵中的路径

        
        
        
    
class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        # S0:check None
        if not board or not board[0]:return False
        row  =len(board)
        col  = len(board[0])
        # S1:def dfs and backtracking
        def dfs(_i,_j,k):
            if not (0<=_i<row) or not (0<=_j<col) or board[_i][_j]!=word[k]: return False
            # S2: True condition
            if k == len(word)-1:return True
            # S1
            board[_i][_j] =''
            res = dfs(_i + 1, _j, k + 1) or dfs(_i - 1, _j, k + 1) or dfs(_i, _j + 1, k + 1) or dfs(_i, _j - 1, k + 1)
            # S1
            board[_i][_j]=word[k]
            return res
        
        # S4 for to call dfs
        for _i in range(row):
            for _j in range(col):
                if dfs(_i,_j,0):return True
        return False

1. 机器人的运动范围

        
        
        
    
class Solution:
    def movingCount(self, m: int, n: int, k: int) -> int:
        visited = [[False]*n for _ in range(m)]
        self.res = 0
        def dfs(i, j):
            if not (0<=i<m) or not (0<=j<n) or visited[i][j] or (i//10+i%10+j//10+j%10>k):
                return
            visited[i][j] = True
            self.res += 1
            dfs(i+1, j)
            dfs(i-1, j)
            dfs(i, j+1)
            dfs(i, j-1)
            #visited[i][j] = False
        dfs(0, 0)
        return self.res

1. 字符串的排列

        
        
        
    
class Solution:
    def permutation(self, s: str) -> List[str]:
        c, res = list(s), []
        def dfs(x):
            if x == len(c) - 1:
                res.append(''.join(c))   # 添加排列方案
                return
            dic = set()
            for i in range(x, len(c)):
                if c[i] in dic: continue # 重复，因此剪枝
                dic.add(c[i])
                c[i], c[x] = c[x], c[i]  # 交换，将 c[i] 固定在第 x 位
                dfs(x + 1)               # 开启固定第 x + 1 位字符
                c[i], c[x] = c[x], c[i]  # 恢复交换
        dfs(0)
        return res

排序

1. 调整数组顺序使奇数位于偶数前面

        
        
        
    
class Solution:
    def exchange(self, nums: List[int]) -> List[int]:
        #2 points
        _i,_j = 0,len(nums)-1
        while _i<_j:
            #_i+=1
            while _i<_j and nums[_i]%2 == 1:_i+=1
            #_j-=1
            while _i<_j and nums[_j]%2 == 0:_j-=1
            #swap
            nums[_i],nums[_j] = nums[_j],nums[_i]
        return nums

1. 把数组排成最小的数

        
        
        
    
class Solution:
    def minNumber(self, nums: List[int]) -> str:
        def quick_sort(l , r):
            if l >= r: return
            # left & right point
            i, j = l, r
            while i < j:
                while strs[j] + strs[l] >= strs[l] + strs[j] and i < j: j -= 1
                while strs[i] + strs[l] <= strs[l] + strs[i] and i < j: i += 1
                strs[i], strs[j] = strs[j], strs[i]
            strs[i], strs[l] = strs[l], strs[i]
            quick_sort(l, i - 1)
            quick_sort(i + 1, r)
        
        strs = [str(num) for num in nums]
        quick_sort(0, len(strs) - 1)
        return ''.join(strs)

1. 数组中的逆序对

        
        
        
    
class Solution:
    def reversePairs(self, nums: List[int]) -> int:
        def merge_sort(l, r):
            # 终止条件
            if l >= r: return 0
            # 递归划分
            m = (l + r) // 2
            res = merge_sort(l, m) + merge_sort(m + 1, r)
            # 合并阶段
            i, j = l, m + 1
            tmp[l:r + 1] = nums[l:r + 1]
            for k in range(l, r + 1):
                if i == m + 1:
                    nums[k] = tmp[j]
                    j += 1
                elif j == r + 1 or tmp[i] <= tmp[j]:
                    nums[k] = tmp[i]
                    i += 1
                else:
                    nums[k] = tmp[j]
                    j += 1
                    res += m - i + 1 # 统计逆序对
            return res
        
        tmp = [0] * len(nums)
        return merge_sort(0, len(nums) - 1)

动态规划

10.1 斐波那契数列

        
        
        
    
class Solution:
    def fib(self, n: int) -> int:
        #S0: 
        if n==0:return 0
        if n==1:return 1
        #S1: Def dp is line or matrix and identify parameter 
        #S3: Init dp
        dp = [0] * (n+1)

        dp[0]=0
        dp[1]=1
        # S4: Decide loop wany
        for _i in range(2,n+1):
            # S2: Recurrence Formula
            dp[_i] = dp[_i-1]+dp[_i-2]
        return dp[-1] % 1000000007

10.2 矩形覆盖

10.3 跳台阶

        
        
        
    
class Solution:
    def numWays(self, n: int) -> int:
        dp = [1,1]
        # 1,1,2,3,5
        for i in range(2,n+1):
           dp.append(dp[i-1]+dp[i-2])
        return dp[-1] % 1000000007

10.4 变态跳台阶

1. 连续子数组的最大和

        
        
        
    
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        # use dp
        # 1.def dp and def n means
        n = len(nums)
        # 3.init dp
        dp = [0] * n
        # 4.decide loop
        for _i in range(n):
            # 2.Recurrence Formula
            if dp[_i-1]>0: dp[_i] = dp[_i-1]+nums[_i]
            else:dp[_i] = nums[_i]
        # 5.decide return
        return max(dp)

1. 礼物的最大价值

        
        
        
    
class Solution:
    def maxValue(self, grid: list[list[int]]) -> int:
        # DP
        if not grid or not grid[0]:return 0
        #print(grid)
        # 1.def dp
        row = len(grid)
        col = len(grid[0])
        dp=[[0]*col for _ in range(row)]
        
        # 3.init dp
        dp[0][0] =grid[0][0]
        for _i in range(1,row):
            dp[_i][0] = dp[_i-1][0]+grid[_i][0]
        for _j in range(1,col):
            dp[0][_j] = dp[0][_j-1]+grid[0][_j]
        #print(dp)
        # 4.decide loop
        for _i in range(1,row):
            for _j in range(1,col):
                # 2.recurrence formula
                dp[_i][_j] = max(dp[_i-1][_j]+grid[_i][_j],dp[_i][_j-1]+grid[_i][_j])
        #print(dp)
        # 5. decide return
        return dp[-1][-1]

1. 最长不含重复字符的子字符串

        
        
        
    
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if not s:return 0
        dic ={}
        #1.def dp [] and i means
        ans = 1
        n = len(s)
        dp=[0]*n
        #3.init dp
        dp[0] = 1
        dic[s[0]]=0 # init dic
        #4.def loop
        for _i in range(1,n):
        #2.recurrence formula
            if s[_i] not in dic: # char not repeat
                dp[_i] = dp[_i-1]+1
            else:
                _repeat = dic[s[_i]] #char repeat then compare pre,cur interval
                cur_interval = _i-_repeat
                dp[_i] = dp[_i-1]+1 if cur_interval>dp[_i-1] else cur_interval
            dic[s[_i]] = _i
            ans =max(dp[_i],ans)
        # return
        return ans

1. 丑数

        
        
        
    
class Solution:
    def nthUglyNumber(self, n: int) -> int:
        #1.def dp and i means
        #2.recurrence formula
        #3.init dp
        #4.decide loop
        dp = [1] * n
        _a, _b, _c = 0,0,0
        for _i in range(1, n):
            n2, n3, n5 = dp[_a] * 2, dp[_b] * 3, dp[_c] * 5
            # dp[i] = min(dp[a]*2,dp[b]*3,dp[c]*5) three points
            dp[_i] = min(n2, n3, n5)
            if dp[_i] == n2: _a += 1
            if dp[_i] == n3: _b += 1
            if dp[_i] == n5: _c += 1
        return dp[-1]

1. n 个骰子的点数

        
        
        
    
class Solution:
    def dicesProbability(self, n: int) -> List[float]:
        dp = [1 / 6] * 6
        for i in range(2, n + 1):
            tmp = [0] * (5 * i + 1)
            for j in range(len(dp)):
                for k in range(6):
                    tmp[j + k] += dp[j] / 6
            dp = tmp
        return dp

1. 构建乘积数组

        
        
        
    
class Solution:
    def constructArr(self, a: List[int]) -> List[int]:
        # def varible
        n = len(a)
        res = [1] * n
        
        # loop
        tmp = 1
        for _i in range(n):
            res[_i] = tmp
            tmp *= a[_i]
            #print(res)
        # reversed loop
        tmp =1
        for _j in reversed(range(n)):
            res[_j] *= tmp 
            tmp *= a[_j]
            #print(res)
        return res

数学

1. 数组中出现次数超过一半的数字

        
        
        
    
class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        n = len(nums)//2
        if len(nums) ==1: return nums[0]
        dic = {}
        for num in nums:
            if num not in dic:
                dic[num]=1
            else:
                if dic[num]>=n:
                    return num
                else:
                    dic[num] += 1

1. 圆圈中最后剩下的数

        
        
        
    
class Solution:
    def lastRemaining(self, n: int, m: int) -> int:
        ans = 0
        for i in range(2,n+1):
            ans = (ans+m) % i
        return ans

1. 从 1 到 n 整数中 1 出现的次数

        
        
        
    
class Solution:
    def countDigitOne(self, n: int) -> int:
        digit, res = 1, 0
        high, cur, low = n // 10, n % 10, 0
        while high != 0 or cur != 0:
            if cur == 0: res += high * digit
            elif cur == 1: res += high * digit + low + 1
            else: res += (high + 1) * digit
            low += cur * digit
            cur = high % 10
            high //= 10
            digit *= 10
        return res

位运算

1. 二进制中 1 的个数

        
        
        
    
class Solution:
    def hammingWeight(self, n: int) -> int:
        res =0
        while n:
            res+= n&1
            n>>=1
        return res

1. 数组中只出现一次的数字

        
        
        
    
class Solution:
    def singleNumbers(self, nums: List[int]) -> List[int]:
        dic,ans = {},[]
        for num in nums:
            if num not in dic:
                dic[num] =True
            else:
                dic[num] = False
        for k,v in dic.items():
            if v: ans.append(k)
        return ans

其它

1. 打印从 1 到最大的 n 位数

        
        
        
    
class Solution:
    def printNumbers(self, n: int) -> List[int]:
        res =[]
        for i in range(1,10**n):
            res.append(i)
        return res

1. 正则表达式匹配

        
        
        
    
class Solution:
    def isMatch(self, s: str, p: str) -> bool:
        m, n = len(s) + 1, len(p) + 1
        dp = [[False] * n for _ in range(m)]
        dp[0][0] = True
        # 初始化首行
        for j in range(2, n, 2):
            dp[0][j] = dp[0][j - 2] and p[j - 1] == '*'
        # 状态转移
        for i in range(1, m):
            for j in range(1, n):
                if p[j - 1] == '*':
                    if dp[i][j - 2]: dp[i][j] = True                              # 1.
                    elif dp[i - 1][j] and s[i - 1] == p[j - 2]: dp[i][j] = True   # 2.
                    elif dp[i - 1][j] and p[j - 2] == '.': dp[i][j] = True        # 3.
                else:
                    if dp[i - 1][j - 1] and s[i - 1] == p[j - 1]: dp[i][j] = True # 1.
                    elif dp[i - 1][j - 1] and p[j - 1] == '.': dp[i][j] = True    # 2.
        return dp[-1][-1]

1. 表示数值的字符串

        
        
        
    
class Solution:
    def isNumber(self, s: str) -> bool:
        states = [
            { ' ': 0, 's': 1, 'd': 2, '.': 4 }, # 0. start with 'blank'
            { 'd': 2, '.': 4 } ,                # 1. 'sign' before 'e'
            { 'd': 2, '.': 3, 'e': 5, ' ': 8 }, # 2. 'digit' before 'dot'
            { 'd': 3, 'e': 5, ' ': 8 },         # 3. 'digit' after 'dot'
            { 'd': 3 },                         # 4. 'digit' after 'dot' (‘blank’ before 'dot')
            { 's': 6, 'd': 7 },                 # 5. 'e'
            { 'd': 7 },                         # 6. 'sign' after 'e'
            { 'd': 7, ' ': 8 },                 # 7. 'digit' after 'e'
            { ' ': 8 }                          # 8. end with 'blank'
        ]
        p = 0                           # start with state 0
        for c in s:
            if '0' <= c <= '9': t = 'd' # digit
            elif c in "+-": t = 's'     # sign
            elif c in "eE": t = 'e'     # e or E
            elif c in ". ": t = c       # dot, blank
            else: t = '?'               # unknown
            if t not in states[p]: return False
            p = states[p][t]
        return p in (2, 3, 7, 8)

1. 数字序列中的某一位数字

        
        
        
    
class Solution:
    def findNthDigit(self, n: int) -> int:
        digit, start, count = 1, 1, 9
        while n > count: # 1.
            n -= count
            start *= 10
            digit += 1
            count = 9 * start * digit
        num = start + (n - 1) // digit # 2.
        return int(str(num)[(n - 1) % digit]) # 3.

1. 把数字翻译成字符串

        
        
        
    
class Solution:
    def translateNum(self, num: int) -> int:
        s = str(num)
        # 1.def dp
        n = len(s)
        if n<2:return n
        dp =[0]*(n+1)
        # 3.init dp
        dp[0] = 1
        dp[1] =1
        # 4.decide loop
        for _i in range(2,n+1):
        # 2.recurrence formula
            if '10'<=s[_i-2:_i]<='25':
                dp[_i] = dp[_i-1]+dp[_i-2]                
            else:
                dp[_i] =dp[_i-1]
        # 5.return
        return dp[-1]

1. 扑克牌顺子

        
        
        
    
class Solution:
    def isStraight(self, nums: List[int]) -> bool:
        repeat = set()
        ma, mi = 0, 14
        for num in nums:
            if num == 0: continue # 跳过大小王
            ma = max(ma, num) # 最大牌
            mi = min(mi, num) # 最小牌
            if num in repeat: return False # 若有重复，提前返回 false
            repeat.add(num) # 添加牌至 Set
        return ma - mi < 5 # 最大牌 - 最小牌 < 5 则可构成顺子

1. 求 1+2+3+…+n

        
        
        
    
class Solution:
    # recurion
    def sumNums(self, n: int) -> int:
        # sum = 0
        sum_n= 0
        def rcur(n):
            if n==0:
                return 0
            r = rcur(n-1)
            # regression
            nonlocal sum_n
            sum_n+=r
            return n
        rcur(n)
        # add n
        sum_n=sum_n+n
        return sum_n

1. 不用加减乘除做加法

        
        
        
    
class Solution:
    def add(self, a: int, b: int) -> int:
        x = 0xffffffff
        a, b = a & x, b & x
        while b != 0:
            a, b = (a ^ b), (a & b) << 1 & x
        return a if a <= 0x7fffffff else ~(a ^ x)

1. 把字符串转换成整数

        
        
        
    
class Solution:
    def strToInt(self, str: str) -> int:
        int_max, int_min = 2**31 - 1, -2**31
        str = str.strip()
        if not str:
            return 0
        state = [
            {'s':1, 'd':2, 't':3}, #0起始状态
            {'s':3, 'd':2, 't':3}, #1符号状态
            {'s':3, 'd':2, 't':3}, #2数字状态
            {'s':3, 'd':3, 't':3}  #3终止状态
        ]
        cur, res, flag = 0, 0, 1
        for i in str:
            if i in '+-':
                c = 's'
            elif i.isdigit():
                c = 'd'
            else:
                c = 't'
            cur = state[cur][c]
            if cur == 2:
                res = 10*res + ord(i) - ord('0')
                res = min(int_max, res) if flag == 1 else min(-int_min, res)
            elif cur == 1:
                flag = 1 if i == '+' else -1
        return res*flag 

8种模型

xxxx — Thu, 17 Mar 2022 18:45:43 +0800

STAR

用于工作总结、面试 S 背景基于什么样的情况 T 任务设定了什么样的目标 A 行动用了什么样的方案 R 结果得到了什么样的结果

SCQA

用于开会、营销文案、演讲 S 背景基于什么样的情况 C 冲突遇到了什么问题 Q 问题需要如何解决 A 回答提出了什么样的方案

5W2H

用于计划、推动 What 目的是什么 why 为什么 who 谁去做 when 什么时候 where 在哪

how 方案是什么 how much 成本是多少

which one is better

用于说服、争取

FOSSA

用于说服别人、处理投诉、跨部门沟通 F 认同感受 O 共同目标 S 现状 S 解决方案 A 达成共识

Yes+And 法则

用于拒绝别人

正面的肯定肯定的原因自己的难处

Resume

xxxx — Mon, 14 Mar 2022 10:09:08 +0800

中文简历

我的简历

英文简历

My Resume

云上软件架构

xxxx — Wed, 20 Oct 2021 17:00:15 +0800

摘要

什么是云原生？
- 什么是12要素
云原生应该关注什么？
- 微服务架构
- 敏捷基础设施及公共基础服务
- 分布式架构设计
云原生程度的评判标准是什么？
云服务现在如何，未来怎么走？

什么是云原生

云原生的概念最早开始于 2010 年，在当时 Paul Fremantle 的一篇博客中被提及，他一直想用一个词表达一种架构，这种架构能描述应用程序和中间件在云环境中的良好运行状态。因此他抽象出了 Cloud Native 必须包含的属性，只有满足了这些属性才能保证良好的运行状态。当时提出云原生是为了能构建一种符合云计算特性的标准来指导云计算应用的编写。

后来到 2013 年 Matt Stine 在推特上迅速推广云原生概念，并在 2015 年《迁移到云原生架构》一书中定义了符合云原生架构的特征：12 因素、微服务、自服务、基于 API 协作、扛脆弱性。而由于这本书的推广畅销，这也成了很多人对云原生的早期印象，同时云原生也被 12 要素变成了一个抽象的概念。Matt Stine 认为在单体架构向 Cloud Native 迁移的过程中，需要文化、组织、技术共同变革。

12要素

2012 年，Heroku 创始人 Adam Wiggins 发布十二要素应用宣言。它为构建一个优雅的互联网应用，定义了需要遵循的一些基本原则和方法论，也广泛影响了众多的微服务应用架构。十二要素重点关注：应用程序的健康成长，开发者之间的有效的协作，以及避免软件架构腐化的影响。

基准代码：一份基准代码，多份部署，使用 GIT 或者 SVN 管理代码，并且有明确的版本信息。
依赖：显示声明依赖。
配置：环境中存储配置。
后端服务：把后端服务当作附加资源。后端服务是指程序运行所需要的通过网络调用的各种服务，如数据库（MySQL、CouchDB）、消息/队列系统（RabbitMQ、Beanstalkd）、SMTP 邮件发送服务（Postfix），以及缓存系统（Memcached）。
构建、发布、运行：严格分离构建和运行。
进程：以一个或多个无状态进程运行应用，如果存在状态，应该将状态外置到后端服务中，例如数据库、缓存等。
端口绑定：通过端口绑定提供服务，应用通过端口绑定来提供服务，并监听发送至该端口的请求。
并发：通过进程模型进行扩展，扩展方式有进程和线程两种。进程的方式使扩展性更好，架构更简单，隔离性更好。线程扩展使编程更复杂，但是更节省资源。
易处理：快速启动和优雅终止可最大化健壮性，只有满足快速启动和优雅终止，才能使服务更健壮。
开发环境与线上环境等价：尽可能保持开发、预发布、线上环境相同。
日志：把日志当作事件流，微服务架构中服务数量的爆发需要具备调用链分析能力，快速定位故障。
管理进程：把后台管理任务当作一次性进程运行，一些工具类在生产环境上的操作可能是一次性的，因此最好把它们放在生产环境中执行，而不是本地。

12 要素应用为我们提供了很好的架构指导，帮助我们：

测试评审方法

xxxx — Thu, 30 Sep 2021 09:05:43 +0800

测试方法

软件测试阶段

单元测试重点：模块接口，局部数据结构，重要的执行通路，出错处理通路，边界条件
集成测试非渐增式，渐增式
系统测试确认测试（需求说明书检查，软件配置复查），验收测试（alpha，beta）

白盒测试和黑盒测试

白盒测试语句覆盖，判定覆盖，条件覆盖，判定/条件覆盖，条件组合覆盖，路径覆盖
黑盒测试等价类划分，边值分析，错误推测，因果图
缺陷的分类和级别分类：输入/输出错误，逻辑错误，计算错误，接口错误，数据错误级别：轻微，中等，使人不悦，影响使用，严重，非常严重，极为严重，无法容忍，灾难性，传染性
调试排错策略：原始类，回溯类，排除类

评审方法

软件需求评审，概要设计评审，详细设计评审，软件验证和确认评审，功能检查，物理检查，综合检查，管理评审

注意：不应以测试代替评审，评审人员应关注产品而不应评论开发人员，评审人员应关注实质性问题，评审会议不应变为问题解决方案讨论会，评审应被安排进入项目计划，评审参与者应了解整个评审过程，评审人员事先应对评审材料充分了解，应重视评审的组织工作

验证与确认

验证：合同验证，过程验证，需求验证，设计验证，编码验证，集成验证，文档验证确认

测试自动化

测试用例生成，测试执行控制，测试结果对比，测试结果分析，总测试状况的统计与报表产生

面向对象测试

OOA测试，OOD测试，OOP测试，单元测试，集成测试，系统测试

[转载]微服务架构的设计模式

xxxx — Mon, 27 Sep 2021 16:14:27 +0800

独享数据库（Database per Microservice）

当一家公司将大型单体系统替换成一组微服务，首先要面临的最重要决策是关于数据库。单体架构会使用大型中央数据库。即使转移到微服务架构许多架构师仍倾向于保持数据库不变。虽然有一些短期收益，但它却是反模式的，特别是在大规模系统中，微服务将在数据库层严重耦合，整个迁移到微服务的目标都将面临失败（例如，团队授权、独立开发等问题）。

更好的方法是为每个微服务提供自己的数据存储，这样服务之间在数据库层就不存在强耦合。这里我使用数据库这一术语来表示逻辑上的数据隔离，也就是说微服务可以共享物理数据库，但应该使用分开的数据结构、集合或者表，这还将有助于确保微服务是按照领域驱动设计的方法正确拆分的。

优点

数据由服务完全所有。
服务的开发团队之间耦合度降低。

缺点

服务间的数据共享变得更有挑战性。
在应用范围的保证 ACID 事务变得困难许多。
细心设计如何拆分单体数据库是一项极具挑战的任务。

何时使用独享数据库

在大型企业应用程序中。
当团队需要完全把控微服务以实现开发规模扩展和速度提升。

何时不宜使用独享数据库

在小规模应用中。
如果是单个团队开发所有微服务。

可用技术示例

所有 SQL、 NoSQL 数据库都提供数据的逻辑分离（例如，单独的表、集合、结构、数据库）。

延伸阅读

微服务模式：独享数据库
https://microservices.io/patterns/data/database-per-service.html

分布式数据存储
https://docs.microsoft.com/en-us/dotnet/architecture/cloud-native/distributed-data

事件源（Event Sourcing）

在微服务架构中，特别使用独享数据库时，微服务之间需要进行数据交换。对于弹性高可伸缩的和可容错的系统，它们应该通过交换事件进行异步通信。在这种情况，您可能希望进行类似更新数据库并发送消息这样的原子操作，如果在大数据量的分布式场景使用关系数据库，您将无法使用两阶段锁协议（2PL），因为它无法伸缩。而 NoSQL 数据库因为大多不支持两阶段锁协议甚至无法实现分布式事务。

在这些场景，可以基于事件的架构使用事件源模式。在传统数据库中，直接存储的是业务实体的当前“状态”，而在事件源中任何“状态”更新事件或其他重要事件都会被存储起来，而不是直接存储实体本身。这意味着业务实体的所有更改将被保存为一系列不可变的事件。因为数据是作为一系列事件存储的，而非直接更新存储，所以各项服务可以通过重放事件存储中的事件来计算出所需的数据状态。

优点

为高可伸缩系统提供原子性操作。
自动记录实体变更历史，包括时序回溯功能。
松耦合和事件驱动的微服务。

缺点

从事件存储中读取实体成为新的挑战，通常需要额外的数据存储（CQRS 模式）。
系统整体复杂性增加了，通常需要领域驱动设计。
系统需要处理事件重复（幂等）或丢失。
变更事件结构成为新的挑战。

何时使用事件源

使用关系数据库的、高可伸缩的事务型系统。
使用 NoSQL 数据库的事务型系统。

开发管理

xxxx — Tue, 14 Sep 2021 15:20:55 +0800

项目的范围、时间与成本

项目范围管理

项目启动
范围计划编制
范围定义
范围核实
范围变更

项目成本管理

资源计划编制
成本估算
成本预算
成本控制

项目时间管理

活动定义
活动排序
活动历时估算
进度计划编制
进度控制

配置管理与文档管理

软件配置管理概念

配置标识
版本控制
状态统计
审计与审查
生产
过程管理
小组协作

软件配置管理的解决方案

各种版本控制工具

软件文档管理

软件文档的作用
1. 管理依据
2. 任务之间联系的凭证
3. 质量保证
4. 培训与参考
5. 软件维护支持
6. 历史档案
7. 销售可能
文档的归类
1. 开发文档
2. 产品文档
3. 管理文档
文档编制计划
1. 列出应编制文档的目录
2. 提示编制文档应参考的标准
3. 指定文档管理员
4. 提供编制文档所需要的条件
5. 明确保证文档质量的方法
6. 绘制进度表
对文档质量的要求
1. 针对性
2. 准确性
3. 清晰性
4. 完整性
5. 灵活性

软件需求管理

需求变更

项目启动阶段的变更预防
项目实施阶段的需求变更

需求跟踪

确定需求变更控制过程
进行需求变更影响分析
建立需求基准版本和需求控制版本文档
维护需求变更的历史纪录
跟踪每项需求的状态

软件开发的质量与风险

软件质量管理

软件质量计划
软件质量保证
软件质量控制
1. 软件评审
2. 测试

项目风险管理

项目风险管理的概念
1. 内部技术风险
2. 内部非技术风险
  1. 公司战略变化、管理人员水平、没有在预算内完成进度
3. 外部法律风险
4. 外部非法律风险
  1. 经济环境变化、组织雇佣关系变化
风险管理的过程
1. 风险管理规划
2. 项目风险识别
3. 定性风险分析
4. 定量风险分析
5. 风险应对计划
6. 风险监督与控制

人力资源管理

组织规划

垂直团队组织
水平团队组织
混合团队组织

人员招募

领导能力
沟通技巧
人际交往能力
应付压力能力
培养员工能力
时间管理能力

团队建设

形成阶段
震荡阶段
正规阶段
表现阶段

软件的运行与评价

软件的稳定性与可靠性评价
软件是否满足了用户的需求
软件实施给用户带来的好处

软件过程改进

CMM
CMMI
ISO 9000
ITIL