1. def phazed_phase_type(phase):
    2.     # Implement this function.
    4.     # 用字典定义每张牌的数值和对应的花色
    5.     value_dict = {'A': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9, '0': 10, 'J': 11, 'Q': 12,
    6.                   'K': 13}
    7.     suit_dict = {'S': 'black', 'H': 'red', 'D': 'red', 'C': 'black'}
    8.     phase_type = []
    9.     result = []
    10.     for group in phase:
    11.     # 获取每张牌的值，并转换成整数类型
    12.         value_list = [_[0] for _ in group]
    13.         int_value_list = [value_dict[i] for i in value_list]
    14.         # 获取每张牌的花色，并转成红色或者黑色
    15.         suit_list = [_[1] for _ in group]
    16.         color_list = [suit_dict[i] for i in suit_list]
    18.         # 判断是否为第一个组合
    19.         def is_one():
    20.             if len(group) == 3:
    21.                 # 将牌中的万能牌去掉后，如果牌面值只有一种，则符合第一中组合
    22.                 s1 = list(set(value_list) - set('A'))
    23.                 if len(s1) == 1:
    24.                     result.append(1)
    26.         # 判断是否为第二个组合
    27.         def is_two():
    28.             if len(group) == 7:
    29.                 # 从该组牌中去除万能牌
    30.                 for i in range(len(value_list) - 1, 0, -1):
    31.                     if value_list[i] == 'A':
    32.                         suit_list.pop(i)
    33.                 # 去掉万能牌后，如果花色只有一种，则符合第二种组合
    34.                 s2 = set(suit_list)
    35.                 if len(s2) == 1:
    36.                     result.append(2)
    38.         # 判断是否为第三个组合
    39.         def is_three():
    40.             if sum(int_value_list) == 34:
    41.                 result.append(3)
    43.         # 判断该牌组是否排序
    44.         def is_sorted():
    45.             a_index = []  # 代表牌面为A所在的位置
    46.             not_a = []  # 代表牌面不为A所在的位置
    47.             for index, value in enumerate(int_value_list):
    48.                 if value != 1:
    49.                     not_a.append(index)
    50.                 else:
    51.                     a_index.append(index)
    52.             # 找到第一个不是A牌的值，将A的值根据其位置进行转换为相应的牌
    53.             for i in a_index:
    54.                 color_list[i] = color_list[not_a[0]]  # 将A牌的颜色换成一个不是A牌的颜色
    55.                 if i < not_a[0]:
    56.                     # 如果A牌在第一个不是A牌的前面，则进行减数处理
    57.                     a_value = int_value_list[not_a[0]] - (not_a[0] - i)
    58.                     # 如果该牌面值小于0，则直接退出
    59.                     if a_value > 0:
    60.                         int_value_list[i] = a_value
    61.                     else:
    62.                         return False
    63.                 else:
    64.                     # 如果A牌在第一个不是A牌的后面，则进行加数处理
    65.                     a_value = int_value_list[not_a[0]] + (i - not_a[0])
    66.                     # 如果该牌面值大于13，则直接退出
    67.                     if a_value < 13:
    68.                         int_value_list[i] = a_value
    69.                     else:
    70.                         return False
    71.             # 判断替换A牌后的牌是否按照顺序排列
    72.             for j in range(1, 4):
    73.                 if int_value_list[j] - int_value_list[j - 1] != 1:
    74.                     return False
    75.             else:
    76.                 return True
    78.         # 判断是否为第四个组合
    79.         def is_four():
    80.             if len(group) == 4:
    81.                 # 将牌中的万能牌去掉后，如果牌面值只有一种，则符合第三种组合
    82.                 s3 = list(set(value_list) - set('A'))
    83.                 if len(s3) == 1:
    84.                     result.append(4)
    86.         # 判断是否为第五个组合
    87.         def is_five():
    88.             if len(group) == 8:
    89.                 if is_sorted():
    90.                     result.append(5)
    93.         # 判断是否为第六个组合
    94.         def is_six():
    95.             red_sum = 0     # 记录红色牌的数值综合
    96.             black_sum = 0       # 记录黑色牌的数值综合
    97.             for i in range(len(group)):
    98.                 if color_list[i] == 'red':
    99.                     red_sum += int_value_list[i]
    100.                 else:
    101.                     black_sum += int_value_list[i]
    102.             if red_sum == 34 or black_sum == 34:
    103.                 result.append(6)
    106.         # 判断是否为第七个组合
    107.         def is_seven():
    108.             if len(group) == 4:
    109.                 if is_sorted():
    110.                     if len(set(color_list)) == 1:
    111.                         result.append(7)
    113.         # 判断是否该组牌中有两个以上"natural" cards
    114.         if value_list.count('A') <= len(value_list) - 2:
    115.             is_one()
    116.             is_two() 
    117.             is_four()
    118.             is_five()
    119.             is_seven()
    120.         # 判断是否符合第六、七组合
    121.         is_three()
    122.         is_six()
    124.     if result.count(1) >= 2:
    125.         phase_type.append(1)
    126.     if result.count(2) >= 1:
    127.         phase_type.append(2)
    128.     if result.count(3) >= 2:
    129.         phase_type.append(3)
    130.     if result.count(4) >= 2:
    131.         phase_type.append(4)
    132.     if result.count(5) >= 1:
    133.         phase_type.append(5)
    134.     if result.count(6) >= 2:
    135.         phase_type.append(6)
    136.     if result.count(7) >= 1 and result.count(4) >= 1:
    137.         phase_type.append(7)
    139.     return phase_type
    142. if __name__ == '__main__':
    143.     # Example calls to the function.
    145.     print(phazed_phase_type([['2C', '2S', '2H'], ['7H', '7C', 'AH']]))
    146.     print(phazed_phase_type([['2C', '2C', '4C', 'KC', '9C', 'AH', 'JC']]))
    147.     print(phazed_phase_type([['2C', 'KH', 'QS', '7H'],
    148.                              ['3H', '7S', '0D', 'KD', 'AD']]))
    149.     print(phazed_phase_type([['4H', '4S', 'AC', '4C'],
    150.                              ['7H', '7C', 'AH', 'AC']]))
    151.     print(phazed_phase_type([['4H', '5S', 'AC', '7C',
    152.                               '8H', 'AH', '0S', 'JC']]))
    153.     print(phazed_phase_type([['2C', 'KC', 'QS', '7C'],
    154.                              ['3H', '7H', '0D', 'KD', 'AD']]))
    155.     print(phazed_phase_type([['4H', '5D', 'AC', '7H'],
    156.                              ['7H', '7C', 'AH', 'AS']]))
    157.     print(phazed_phase_type([['4H', '5D', '7C', 'AC'], ['AC', 'AS', 'AS']]))