第二次结对编程作业

链接

结对同学的博客链接

本作业博客的链接

Github项目地址

具体分工

• 潘海东：后端，前端，博客撰写
• 方瑞雄：前端，博客撰写

演示视频

• 点击链接播放即可，可能需要一些广告由于B站审核通过不了，只能发到优酷，委屈各位，但是还是希望大家先看一下我们的视频!
  

https://v.youku.com/v_show/id_XNDM5ODE4NzYwMA==.html?spm=a2h3j.8428770.3416059.1

• 强烈推荐我们提供体验版微信小程序，可以直接用微信扫码体验游戏，但是需要管理员通过，请提前联系管理员wx：phd02428 qq：1647790440（哈哈哈，这二维码超级大）（一开始是想完全发布出去，只需要在微信搜索我们小程序的名字就可以直接使用，且不需要管理员的同意，但是由于题材比较特殊，可能涉及赌博就没办法通过审核，发布不了）

  请一定一定联系下管理员，不然就算是申请通过了，也不会收到通知的。

  由于为了保证完整的背景图，取消掉了微信小程序原有的顶部导航栏，没有了返回按钮，因此这个小程序对苹果用户不友好，想返回上一个页面只能重新扫码进入小程序，安卓用户可以直接用返回键回到上一个页面。（之后会想办法更新添加返回按钮没有之后，都是假的）赌徒，要么从头做人，要么一赌到底！

PSP表格

PSP2.1	Personal Software Process Stages	预估耗时(min)	实际耗时(min)
Planning	计划	60	60
Estimate	估计这个任务需要多少时间	60	80
Development	开发	2160	2220
Analysis	需求分析 (包括学习新技术)	240	240
Design Spec	生成设计文档	120	150
Design Review	设计复审	60	60
Coding Standard	代码规范 (为开发制定合适的规范)	120	120
Design	具体设计	240	200
Coding	具体编码	960	1000
Code Review	代码复审	120	150
Test	测试 (自我测试,修改,提交修改)	300	300
Reporting	报告	210	270
Test Report	测试报告	120	180
Size Measurement	计算工作量	60	60
Postmortem & Process Improvement Plan	事后总结 并提出过程改进计划	30	30
		2430	2550

解题思路描述与设计实现说明

网络接口的使用

不懂接口的使用要写什么，要说明什么，就是直接使用永福写好的接口。助教姐姐说贴出代码，那我就贴出代码。（因为接口数量较多，会比较长，所以我就把代码折叠起来了）

这是隐藏起来的代码，点击就可以显示，下面也一样

//登陆，
    wx.request({
      url: 'https://api.shisanshui.rtxux.xyz/auth/login',
      header:{
        'content-type': 'application/json'
      },
      data:{
        username: e.detail.value.username,
        password: e.detail.value.password
      },
      method:"POST",
      success(res) {
        console.log(res.data)
        console.log(res.data.data)
        console.log(res.data.data.token)
        var token = res.data.data.token 
        var userid = res.data.data.user_id
        wx.navigateTo({
          url: "/pages/mine/mine?token=" + token + "&userid=" + userid
        })
      }
    })

//注册
    wx.request({
      url: 'https://api.shisanshui.rtxux.xyz/auth/register',
      header: {
        'content-type': 'application/json'
      },
      data: {
        username: e.detail.value.username,
        password: e.detail.value.password
      },
      method: "POST",
      success(res) {
        console.log(res.data)
        wx.navigateTo({
          url: "/pages/signin/signin"
        })
      }
    })

//开局
    wx.request({
      url: 'https://api.shisanshui.rtxux.xyz/game/open',
      header:{
        "X-Auth-Token":that.data.id_token
      },
      method:"POST",
      success(res){
        console.log(res.data)
        console.log(res.data.data.card)
        that.setData({
          getstring: res.data.data.card,
          id: res.data.data.id
        })
        wx.request({
          url: 'http://sssxfd.top:8080/card_division',
          // url: 'http://172.26.76.171:7777/getcards',
          method:"POST",
          data:{
            cardstring:that.data.getstring
            // card: that.data.getstring
          },
          // header:{
          //   "Content-Type": "application/x-www-form-urlencoded",
          // },
          success(res){
            console.log(res.data)
            that.setData({
              qian:res.data.card[0],
              zhong:res.data.card[1],
              hou:res.data.card[2],
              card:res.data.card,
              qian_image:res.data.card_image[0],
              zhong_image: res.data.card_image[1],
              hou_image: res.data.card_image[2],
            })
            console.log(that.data.hou_image)
          }
        })
      }
    })

//出牌
    wx.request({
      url: 'https://api.shisanshui.rtxux.xyz/game/submit',
      method:"POST",
      header:{
        "Content-Type":"application/json",
        "X-Auth-Token":that.data.id_token
      },
      data:{
        id:that.data.id,
        card:that.data.card
      },
      success(res){
        console.log(res.data)
        that.setData({
          qian: "success",
          zhong: "success",
          hou: "success",
          getstring:"success",
          card:[],
          qian_image:that.data.qian_image_1,
          zhong_image:that.data.zhong_image_1,
          hou_image:that.data.hou_image_1,
        })
      }
    })

//对局记录
    wx.request({
      url: 'https://api.shisanshui.rtxux.xyz/history',
      method:"GET",
      header:{
        "X-Auth-Token":that.data.id_token
      },
      data:{
        player_id:that.data.user_id,
        limit:100,
        page:0
      },
      success(res){
        console.log(res.data)
        that.setData({
          record_list:res.data.data
        })
        console.log(that.data.record_list)
        // 没错了
      }
    })

//对局详情
    wx.request({
      url: 'https://api.shisanshui.rtxux.xyz/history/' + this.data.play_id,
      method:"GET",
      header:{
        "X-Auth-Token":that.data.id_token
      },
      success(res){
        console.log(res.data)
        console.log(res.data.data.detail)
        if(res.data.status != 3001){
          that.setData({
            play_list: res.data.data.detail,
          })
        }
        console.log(that.data.play_list)
      },
      fail(res){
        console.log(res)
      }
    })

//排行榜
    wx.request({
      url: 'https://api.shisanshui.rtxux.xyz/rank',
      success(res){
        console.log(res)
        that.setData({
          rank_list: res.data
        })
        console.log(that.data.rank_list)
      }
    })

代码组织与内部实现设计

• 前端代码组织

  

• 后端代码组织：

  

说明算法的关键与关键实现部分流程图

我的算法很简单（很直截了当，流程图都不需要分支），只能勉强保证后墩>中墩>前墩，能在不违反游戏规则的情况下出牌。核心思想是利用贪心算法每次在剩余卡牌中找出最大的5张牌。先在13张牌中找出组合最大的5张牌作为后墩，然后在剩余的8张卡牌中找出最大的5张作为中墩，最后剩余的3张卡牌作为前墩。

核心算法（找出当前剩余卡牌中最大的5张牌的）的实现也不难，就按照游戏规则（同花顺-->炸弹-->葫芦-->同花-->顺子-->三条-->两对-->对子-->散牌）的顺序依次寻找，一旦发现符合项就立即返回该项目，并结束函数。

PS：这几天在群里面看到其他同学说他们的py算法运行速度比较慢，要8-10s，我慌了，他们考虑的也太多了吧，算法复杂度也太复杂了吧，我的算法跑起来几乎不需要时间，秒出结果，可见我的算法是有多么智障了。

算法流程图：

关键代码解释

算法部分最难实现的部分是顺子的判断，因为顺子是最特殊的一种组合，既不是用花色来分组，也不是按牌面大小是否相同来分组。我使用了三个函数来实现对顺子卡牌的挑选。由于卡牌牌面是由花色和大小两个部分组成，且大小部分也不全为数字，不能接着判断出牌面大小，需要先进行预处理。我通过字典，先自定义了一个大小比对的变量，用它来完成对牌面大小的判断。

#去掉重复的牌，用来检查顺子
#挑出顺子1
def remove_same_card(card_list):
    #print(card_list)
    card_dict = {'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10,'J':11,'Q':12,'K':13,'A':14}  #大小比对
    number_card_list = []
    digital_card_list = []
    for item in card_list:
        number_card_list.append(item[1:])
    number_card_list = sorted(set(number_card_list),key=number_card_list.index)
    for item in number_card_list:
        digital_card_list.append(card_dict[item])

    #print(digital_card_list)

    return digital_card_list

#单元测试
#print(remove_same_card(['&2', '*2', '$2', '#2', '*7', '*K',  '#K',  '*K', '#K', '*A','$A']))

#挑出顺子2
def select_digital(digital_card_list):
    for i in range(len(digital_card_list)-4):
        if(digital_card_list[i] == digital_card_list[i+4]+4):
            #证明是顺子
            return digital_card_list[i]
            #只能证明存在顺子，但是得不到牌
    return False

#挑出顺子3
def select_straight(card_list):
    digital_card_list = remove_same_card(card_list)
    digital = select_digital(digital_card_list)
    if(digital == False):
        return []
    card_dict = {'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10,'J':11,'Q':12,'K':13,'A':14}  #大小比对
    straight_card_list = []
    for i in range(len(card_list)):
        if(card_dict[card_list[i][1:]] == digital):
            straight_card_list.append(card_list[i])
            digital = digital - 1
        if(len(straight_card_list) == 5):
            break
    return straight_card_list

#单元测试
#print(select_straight(['&A', '*K', '$Q', '#J', '*10', '*9',  '#8',  '*7', '#6', '*5','$4']))

性能分析与改进

性能改进

作业一开始，就本着以能够做出来为第一目标，因此没有考虑过性能改进（理不直气也壮）。但是在算法实现过程种还是有稍微考虑到一些性能问题。比如在挑选顺子的函数中，if(digital_card_list[i] == digital_card_list[i+4]+4):，直接利用牌面大小的差值来判断，可以省略很多的循环次数。

性能分析图

可以发现，在核心函数select_best()下消耗最高的函数是select_straight()，这函数是用来挑选出顺子的函数，因为在挑选顺子的过程中需要多次循环遍历列表，因此时间消耗比较高。

注：这些性能分析是在下面这些例子中跑出来的结果，前面的例子都是永福后端返回的随机卡牌，最后两个例子是人为构造的，为了测试顺子的卡牌组合。

main_function("*4 *3 &4 $Q *Q &10 &A *8 *6 *5 #4 *9 $J")
main_function("&5 $9 &K *7 #Q &J &7 &4 $5 $A *9 $8 #2")
main_function("&5 #J #A &8 &K $7 #3 *8 #8 #5 $6 *3 #2")
main_function("&10 &4 #Q *A *10 #K $4 $K #2 $J &K $3 $6")
main_function("#10 *6 $Q *K &Q #Q *10 *J &5 $3 $8 $K $J")
main_function("#K #4 *10 &Q $6 $J #8 *8 $5 &10 $3 &K $Q")
main_function("$9 $J &A #3 *9 #J *8 $6 #4 $K #7 &9 $7")
main_function("$10 $3 #6 &10 $4 #10 *J $2 &2 *10 $6 *6 $8")
main_function("#K &8 #10 $3 &A #9 *5 &6 *10 $6 #7 *J $J")
main_function("$6 #Q &4 #10 *J &3 *A *2 #J &K *10 $2 &Q")
main_function("#5 #K &2 $K *J &7 #6 *6 *Q *4 &5 &6 #9")
main_function("*9 *5 #4 &J *Q #3 *6 $J $K #7 #Q $Q *10")
main_function("#5 $2 &10 #8 &J *4 *Q $4 *3 &K &8 $Q #9")
main_function("$K #5 &5 *10 &4 #J &A $6 *4 #Q $2 #7 &K")
main_function("$8 &3 #9 $9 $J $Q *3 #6 #Q &K &J &2 #K")
main_function("*7 #3 *5 &3 #7 $8 &5 &J $4 &9 $Q $K *Q")
main_function("#A $2 #3 $4 #5 $6 #7 $8 #9 $10 #J $Q #K")
main_function("#A #2 #3 #4 #5 #6 #7 #8 #9 #10 #J #Q #K")

单元测试

所有功能都使用函数实现，写了很多函数，几乎每个函数在实现过程中都进行了充分的单元测试，虽然有些函数比较简单，但是在实现过程都有进行测试，舍不得去掉。因此下面我贴出了我的理牌算法部分的大部分代码，字符串接收等不涉及算法部分没有展示。(会比较长，一样隐藏了起来)

#把字符串转变成为卡牌 string to list
def stl(card_string):   
    card_list = []
    card_list = card_string.split(' ')
    return card_list

#单元测试
#print(stl("*2 *4 *3 *5 *6 $A *7 *8 *9 *10 *J *Q *K *A"))    

#去掉选出来的卡牌
#需要保证card_list不发生变化
def cut_card(card_list,select_best):
    t_list = card_list
    t_list = sorted(set(card_list) - set(select_best),key=t_list.index)    #保证顺序
    return t_list

#单元测试
#print(cut_card(['*2', '*3', '*4', '*5', '*6', '*7', '*8', '*9', '*10', '*J', '*Q', '*K', '*A'],['*2', '*4', '*5', '*6', '*7', '*8',  '*10',  '*Q', '*K', '*A'])) 


#对卡牌进行排序
def seq(card_list):
    card_dict = {'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10,'J':11,'Q':12,'K':13,'A':14}  #大小比对
    card_dict_ordered = collections.OrderedDict()
    #card_list = []
    card_list_ordered = []
    seq_card_list = []
    #card_list = stl(card_string)
    #card_list = ['*2', '*4', '*5',  '*7','*6', '*8',  '*10',  '*Q', '*K', '*A','$A']   #测试
    #card_list.reverse()                    #测试                  
    #print(card_list)                       #测试
    #a = '2'                                #测试
    #print(card_dict[a])
    for item in card_list:
        str = item[1:]
        value = card_dict[str]
        card_dict_ordered[item] = value
    card_dict_ordered=collections.Counter(card_dict_ordered).most_common()
    for item in card_dict_ordered:
        card_list_ordered.append(item[0])
    #print(card_list_ordered)           #测试
    #print(card_dict_ordered)           #测试
    #print(type(card_dict_ordered))     #测试
    seq_card_list = card_list_ordered
    return seq_card_list
#单元测试
#print(seq(['*2', '*4', '*5',  '*7','*6', '*8',  '*10',  '*Q', '*K', '*A','$A']))

#对卡牌花色进行挑选
def select_suit(card_list):
    spade_list = []     #$
    heart_list = []     #&
    diamond_list = []   ##
    club_list = []      #*
    for item in card_list:
        if(item[0] == '$'):
            spade_list.append(item)
        elif(item[0] == '&'):
            heart_list.append(item)
        elif(item[0] == '#'):
            diamond_list.append(item)
        else:
            club_list.append(item)
    return spade_list,heart_list,diamond_list,club_list
    
#单元测试
# spade_list,heart_list,diamond_list,club_list = select_suit(['&2', '*4', '$5', '#6', '*7', '*8',  '#10',  '*Q', '#K', '*A','$A'])
# print(spade_list)
# print(heart_list)
# print(diamond_list)
# print(club_list)


#分出炸弹、三条、对子、散牌
def select_pair(card_list):
    c_list = card_list.copy()
    c_list.append("^B")   #重点

    one = []
    two = []
    three = []
    four = []

    t_list = []
    for i in range(len(c_list)-1):
        t_list.append(c_list[i])
        #print(t_list)
        #print(c_list[i])
        if(c_list[i][1:] != c_list[i+1][1:]):
            if(len(t_list) == 1):
                one.append(t_list)
            elif(len(t_list) == 2):
                two.append(t_list)
            elif(len(t_list) == 3):
                three.append(t_list)
            else:
                four.append(t_list)
            t_list = []
    #print(card_list)
    #print(c_list)
    return one,two,three,four

#单元测试
# one,two,three,four = select_pair(['&2', '*2', '$2', '#2', '*7', '*K',  '#K',  '*K', '#K', '*A','$A'])
# print(one)
# print(two)
# print(three)
# print(four)


#去掉重复的牌，用来检查顺子
#挑出顺子1
def remove_same_card(card_list):
    #print(card_list)
    card_dict = {'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10,'J':11,'Q':12,'K':13,'A':14}  #大小比对
    number_card_list = []
    digital_card_list = []
    for item in card_list:
        number_card_list.append(item[1:])
    number_card_list = sorted(set(number_card_list),key=number_card_list.index)
    for item in number_card_list:
        digital_card_list.append(card_dict[item])

    #print(digital_card_list)

    return digital_card_list

#单元测试
#print(remove_same_card(['&2', '*2', '$2', '#2', '*7', '*K',  '#K',  '*K', '#K', '*A','$A']))

#挑出顺子2
def select_digital(digital_card_list):
    for i in range(len(digital_card_list)-4):
        if(digital_card_list[i] == digital_card_list[i+4]+4):
            #证明是顺子
            return digital_card_list[i]
            #只能证明存在顺子，但是得不到牌
    return False

#挑出顺子3
def select_straight(card_list):
    digital_card_list = remove_same_card(card_list)
    digital = select_digital(digital_card_list)
    if(digital == False):
        return []
    card_dict = {'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10,'J':11,'Q':12,'K':13,'A':14}  #大小比对
    straight_card_list = []
    for i in range(len(card_list)):
        if(card_dict[card_list[i][1:]] == digital):
            straight_card_list.append(card_list[i])
            digital = digital - 1
        if(len(straight_card_list) == 5):
            break
    return straight_card_list

#单元测试
#print(select_straight(['&A', '*K', '$Q', '#J', '*10', '*9',  '#8',  '*7', '#6', '*5','$4']))

#判断是否存在特殊牌型
#放弃不写
# def if_is_special_card():
#     special_card = []
#     return special_card


#找出剩余手牌中最大的选项
#后敦和中敦都可以使用这个算法
#前敦不需要再一个函数了，去掉中墩和后敦之后剩下的就是前敦了
#主函数
def select_best(card_list):
    card_dict = {'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'10':10,'J':11,'Q':12,'K':13,'A':14}  #大小比对     
    # first_card_list = []
    # second_card_list = []
    # third_card_list = []
    best_card_list = []    #要换成空列表
    if(len(card_list) == 3):
        best_card_list = card_list
        print("乌龙")   #测试 大概率为乌龙
        return best_card_list                   #这个return不太行
    #前期准备
    spade_list,heart_list,diamond_list,club_list = select_suit(card_list)
    one_list,two_list,three_list,four_list = select_pair(card_list)

    #同花顺——》炸弹——》葫芦——》同花——》顺子——》三条——》两对——》对子——》散牌
    #顺子不好搞定 解决了
    #要重新考虑

    #同花顺
    if(len(spade_list) >= 5):
        best_card_list = select_straight(spade_list)
    elif(len(heart_list) >= 5):
        best_card_list = select_straight(heart_list)
    elif(len(diamond_list) >= 5):
        best_card_list = select_straight(diamond_list)
    else:
        best_card_list = select_straight(club_list)

    if(len(best_card_list) != 0):    #这个不是很好
        print("同花顺")  #测试
        return best_card_list

    #炸弹
    if(len(four_list) != 0):
        best_card_list = four_list[0]
        if(len(one_list) != 0):
            best_card_list.append(one_list[-1][0])
            print("炸弹")   #测试
            return best_card_list
        elif(len(two_list) != 0):
            best_card_list.append(two_list[-1][0])
            print("炸弹")  #测试
            return best_card_list
        else:
            best_card_list.append(three_list[-1][0])
            print("炸弹")   #测试
            return best_card_list

    #葫芦
    if(len(two_list) != 0 and len(three_list) != 0):
        best_card_list = three_list[0] + two_list[-1]
        print("葫芦")   #测试
        return best_card_list
    elif(len(two_list) == 0 and len(three_list) >= 2):
        best_card_list = three_list[0] + three_list[1][:1]
        print("葫芦")   #测试
        return best_card_list

    #同花
    if(len(spade_list) >= 5):
        best_card_list = spade_list[:5]
    if(len(heart_list) >= 5):
        if(len(best_card_list) != 0):
            # print(1)
            # print(best_card_list)
            if(card_dict[best_card_list[0][1:]] < card_dict[heart_list[0][1:]]):
                best_card_list = heart_list[:5]
        else:
            best_card_list = heart_list[:5]
    if(len(diamond_list) >= 5):
        if(len(best_card_list) != 0):
            # print(2)
            # print(best_card_list)
            if(card_dict[best_card_list[0][1:]] < card_dict[diamond_list[0][1:]]):
                best_card_list = diamond_list[:5]
        else:
            best_card_list = diamond_list[:5]
    if(len(club_list) >= 5):
        if(len(best_card_list) != 0):
            # print(3)
            # print(best_card_list)
            if(card_dict[best_card_list[0][1:]] < card_dict[club_list[0][1:]]):
                best_card_list = club_list[:5]
        else:
            best_card_list = club_list[:5]
    if(len(best_card_list) != 0):
        print("同花")   #测试
        return best_card_list

    #顺子
    best_card_list = select_straight(card_list)
    if(len(best_card_list) != 0):
        print("顺子")   #测试
        return best_card_list

    #三条
    if(len(three_list) != 0):
        best_card_list = three_list[0] + one_list[0] + one_list[1]
        print("三条")   #测试
        return best_card_list
        
    #两对
    if(len(two_list) >= 2):
        best_card_list = two_list[0] + two_list[1] + one_list[0]
        print("两对")   #测试
        return best_card_list

    #对子
    if(len(two_list) == 1):
        best_card_list = two_list[0] + one_list[0] + one_list[1] + one_list[2]
        print("对子")  #测试
        return best_card_list

    #散牌
    for item in one_list:
        best_card_list = best_card_list + item
        if(len(best_card_list) == 5):
            break
    print("乌龙")   #测试
    return best_card_list


def main_function(card_string):
    #变量定义
    #好像并不是很需要变量定义
    card_list = []
    card_string_list = []
    #前中后
    first_card_list = []
    second_card_list = []
    third_card_list = []
    #四花色
    # spade_list = []     #$
    # heart_list = []     #&
    # diamond_list = []   ##
    # club_list = []      #*
    #取排
    #todo
    #card_string = "#A $2 #3 $4 #5 $6 #7 $8 #9 $10 #J $Q #K"   #测试
    card_list = stl(card_string)
    #理牌
    #排序
    card_list = seq(card_list)
    #spade_list,heart_list,diamond_list,club_list = select_suit(card_list)
    # #后敦
    print("后敦")
    third_card_list = select_best(card_list)
    card_list = cut_card(card_list,third_card_list)   #变成集合的过程中   还能保持有序吗？这是个问题  已经解决
    third_card_list.reverse()
    third_card_string = " ".join(third_card_list)
    print(third_card_string)
    #中敦
    print("中敦")
    second_card_list = select_best(card_list)
    card_list = cut_card(card_list,second_card_list)
    second_card_list.reverse()
    second_card_string = " ".join(second_card_list)
    print(second_card_string)
    #前敦
    print("前敦")
    first_card_list = select_best(card_list)
    first_card_list.reverse()
    first_card_string = " ".join(first_card_list)
    print(first_card_string)
    #first_card_string,second_card_string,third_card_string
    card_string_list.append(first_card_string)
    card_string_list.append(second_card_string)
    card_string_list.append(third_card_string)
    print(card_string_list)
    return card_string_list


#单元测试
#main_function()
# main_function("*4 *3 &4 $Q *Q &10 &A *8 *6 *5 #4 *9 $J")
# main_function("&5 $9 &K *7 #Q &J &7 &4 $5 $A *9 $8 #2")
# main_function("&5 #J #A &8 &K $7 #3 *8 #8 #5 $6 *3 #2")
# main_function("&10 &4 #Q *A *10 #K $4 $K #2 $J &K $3 $6")
# main_function("#10 *6 $Q *K &Q #Q *10 *J &5 $3 $8 $K $J")
# main_function("#K #4 *10 &Q $6 $J #8 *8 $5 &10 $3 &K $Q")
# main_function("$9 $J &A #3 *9 #J *8 $6 #4 $K #7 &9 $7")
# main_function("$10 $3 #6 &10 $4 #10 *J $2 &2 *10 $6 *6 $8")
# main_function("#K &8 #10 $3 &A #9 *5 &6 *10 $6 #7 *J $J")
# main_function("$6 #Q &4 #10 *J &3 *A *2 #J &K *10 $2 &Q")
# main_function("#5 #K &2 $K *J &7 #6 *6 *Q *4 &5 &6 #9")
# main_function("*9 *5 #4 &J *Q #3 *6 $J $K #7 #Q $Q *10")
# main_function("#5 $2 &10 #8 &J *4 *Q $4 *3 &K &8 $Q #9")
# main_function("$K #5 &5 *10 &4 #J &A $6 *4 #Q $2 #7 &K")
# main_function("$8 &3 #9 $9 $J $Q *3 #6 #Q &K &J &2 #K")
# main_function("*7 #3 *5 &3 #7 $8 &5 &J $4 &9 $Q $K *Q")
# main_function("#A $2 #3 $4 #5 $6 #7 $8 #9 $10 #J $Q #K")
# main_function("#A #2 #3 #4 #5 #6 #7 #8 #9 #10 #J #Q #K")

Github的代码签入记录

这是两周来的git签入记录，代码是一直再修改，但是没有每次都上传的git上。而且我们的前端是在微信开发者工具上开发的，就直接发布到微信平台上了，因此git上没有前端的迁入记录。

遇到的代码模块异常或结对困难及解决方法

在完成的过程遇到很很多很多的小问题，其中让我印象最深刻的，应该就是下面这两个了：

• python中list的复制

  在python中，要将list1赋值给list2，不能使用简单的等号赋值 list2 = list1，这样子事实上并没有产生一个新的变量list2，只是将list2指向了list1，类似c里面的指针。当对list2进行修改时，list1也会随之改变。需要使用列表函数copy()来完成列表的复制，list2 = list1.copy()，这样list2是完全独立于list1的新变量。

  参考https://www.cnblogs.com/Black-rainbow/p/9577029.html

  这虽然是一个很简单的问题，但是却很难发现，debug过程相当痛苦，一直不知道错误在哪里。也反映了对python语言的不了解，不熟悉。

• ssl证书的安装

  代码全部写完，一切本地测试正常之后，我就把小程序发布到了微信平台上，可以直接微信扫码使用小程序，结果却发现，所有请求都不能使用了，不只是我自己的后端请求，连永福提供的接口也都不能使用了。不能登录也不能注册，查找资料之后才发现，微信小程序中的request请求，会对域名的合法性需要进行校验。由于在本地环境下开发测试，默认不会对域名的合法性进行校验，所以我就很正常的请求使用我自己搭的后端服务器和永福的接口，也没有任何异常产生，但是发布之后，微信平台就会对小程序的request请求进行合法性检查，但是我自己的还有永福的接口都不符合规定，就全都不能使用了。

  平台要求所有的http请求都需要带ssl证书认证的，也就是https请求，而我自己的后端并没有安装ssl证书，因此还需要去安装ssl证书。

  参考：

  https://blog.csdn.net/dyingstraw/article/details/82698639

  https://blog.csdn.net/ziliwangmoe/article/details/81909151

  然后还要再微信平台上添加域名信任白名单（下图），就可以正常使用了

  

评价队友

• 需要学习的地方：方瑞雄同学对任务的分解到位，减轻了本次作业的压力，与我共同完成了本次作业。
• 需要改进的地方：很早就上床睡觉了，不熬夜，不够努力。

学习进度条

周数	新增代码（行）	累计代码（行）	本周学习耗时（小时）	累计学习耗时（小时）	重要成长
1	0	0	3	3	完成了原型的设计
2	400	400	15	18	完成了后端算法部分
3	500	900	25	43	完成了前端部分，根据作业要求做好前端与后端的对接，实现接口的调用，并完善代码与编写博客

来源：https://www.cnblogs.com/phd1999/p/11681081.html