遇到了进入上科大后大一cs最难的一次作业，难点在于阅读理解，将实际问题abstraction，在算法的思维难度上不是特别的大，基本上四题都是一些模拟题。练习中出现了两个问题：函数操作问题；代码模块化问题

代码模块化

本次作业第二题解决了出1-4张牌的问题；第三题在第二题的基础上寻找5张牌的解法，其中5张牌可以拆分为3张牌而2张牌的组合。那么我们就可以将第二题的代码模块化为函数play()然后将5张牌拆分为3张和2张，分别用play()解决这个问题再合并即可。

代码函数打包模块化步骤如下：

1. 明确函数作用：output input return value的数据类型一定要搞清楚，建议写注释明确函数作用、输入，输出的类型
2. 确定函数scope即：确定未打包代码中，打包的起点和终点
3. 确定函数parameter即：确定未打包代码中的变量和函数parameter a,b,c...的对应。
4. 定义函数打包

我们以本次作业题中的代码为例：将下列代码打包

for i in attack:
        #Processing starts
        if location(data, i) == -1:
            print("Pass")
            m -= 1
            if m <= 0:
                print("Twisted Fate lost all his HP and lost.")
                break
        else:
            loc = location(data, i)
            temp = sort(i)
            found = False
            #output = []
            for j in range(loc, len(data)):
                if len(serch_defense(data[j], temp)) > 0:
                    display = serch_defense(data[j], temp)
                    display.reverse()
                    print(display)
                    data[j] = delete(data[j], display)
                    found = True
                    break
            if found:
                if is_empty(data):
                    break
            else:
                print("Pass")
                m -= 1
                if m <= 0:
                    print("Twisted Fate lost all his HP and lost.")
                    break
            #Processing ends
            
    if m > 0:
        print("Twisted Fate won with", str(m)+"HP", "left.")

• Step1
  明确函数作用和inpout，output。
  目标：将for循环内部代码打包 -> 明确函数作用：玩一局游戏看怎么出牌，如果能赢，能给出出牌方案，以及出牌后的手牌的更新情况，若赢不了不出。
  确定input和output：

#hands_new = data = [[],[]]; defenders = attack = [s1,s2] 
play_round(data, attack) -> (hands_new, defenders)

• Step2
  确定scope：定位源代码打包开始和结束处，见上代码块的Processing starts和Processing ends

• Step3
  确定parameter的对应：
  play_round(data, attack) -> (hands_new, defenders)中data就还是对应原程序中的data手牌，attack对应一轮攻击手牌，即循环变量i

• Step4
  打包代码，把需要的打包进去，不要的扔出来

def play_round(data, attack):
        defender = []
        data_copy = data[:]
        if location(data_copy, attack) == -1:
            return (data_copy, defender)
        else:
            loc = location(data_copy, attack)
            temp = sort(attack)
            found = False
            for j in range(loc, len(data_copy)):
                defender = serch_defense(data_copy[j], temp)
                if len(defender) > 0:
                    defender.reverse()
                    data_copy[j] = delete(data_copy[j], defender)
                    found = True
                    break
            return (data_copy, defender)

函数操作问题

在作业中写一个数组删除操作的时候碰到了如下问题：

def delete(hands, out):
        for i in out:
            hands.remove(i)
        return hands

想写一个函数删除数组中某部分特定的元素但不想改变原数组，想返回一个新数组，但是事与愿违，原数组也一起被删掉了

hands = [1, 2, 3, 4, 5]
out = [1, 2]
delete(hands, out)
print(hands) 
> [3, 4, 5]

这仍然是一个由于list mutable的特效所带来的问题，可以看到python tutor上给出的上段代码最后的执行结果

函数在对list的操作过程中，scope中的hands和全局中的hands共同指向了同一个list，所以在scope中的操作也会把global中的hands一起改掉。

解决：好习惯：python中函数要对list进行操作，现在函数scope内deep copy一份副本！！！

def delete(hands, out):
        h_c = hands[:] #deep copy!!!
        for i in out:
            h_c.remove(i)
        return h_c
print(hands)
> [1, 2, 3, 4, 5]