题目2：从给定列表不重复抽取两个数据，打印令两数之和等于某个值的下标组合，共多少种组合。

题目2：从给定列表不重复抽取两个数据，打印令两数之和等于某个值的下标组合，共多少种组合。
解法1

class train_2:
    
    def __init__(self,nums,target):
        self.nums = nums
        self.target = target
        
    def twosum(self):

        #num_set = list()
        num_index = list()
        for i in range(len(self.nums)):
            for j in range(i+1,len(self.nums)):
                if self.nums[i]+self.nums[j]== self.target:
                    num_index.append((str(i)+str(j)))
        num_len = len(num_index)
        return num_index,num_len

if __name__ == '__main__':
    nums = [1,2,3,1,2,1]
    target = 3
    train_df = train_2(nums,target)
    num_index,num_len = train_df.twosum()
    #print(num_set)
    print(num_index)
    print(num_len)

解法2

def zhishu(max_number):
    
    
    zs = [x for x in range(2,max_number+1)]
    for i in range(max_number):
        if i > len(zs)-1:
            break
        else:
            item = zs[i]
            zs = [x for x in zs if item==x or x%item!=0]
    zs_len = len(zs)
    return zs_len,zs

if __name__=='__main__':
    #min_number=1
    max_number=100
    print(zhishu(max_number))

拓展：
求质数：只可以被1和它本身整除,且满足唯一分解定理（对于任意的一个整数，你都能把它因数分解，而且结果是唯一的）
解法3

def zhishu(min_number,max_number):
    """
    求质数：只可以被1和它本身整除,且满足唯一分解定理（对于任意的一个整数，你都能把它因数分解，而且结果是唯一的）
    params:
        min_number->给定范围下限
        max_number->给定范围上限
    returns:
        zs_len->质数个数
        zs->质数集合列表
    
    """
    if min_number>=2:
        down_number=int(min_number)
    else:
        down_number=2
    zs = [x for x in range(down_number,max_number+1)]
    for i in range(len(zs)):
        if i > len(zs)-1:
            break
        else:
            item = zs[i]
            zs = [x for x in zs if item==x or x%item!=0]
    zs_len = len(zs)
    return zs_len,zs

if __name__=='__main__':
    min_number=2
    max_number=100
    zs_len,zs=zhishu(min_number,max_number)
    print(zs)
    print(zs_len)

更通用一些的算法：n个数加和等于某个数的组合有多少种
解法4

import itertools
def n_sum(array,n,target):
    """
    n个数加和等于某个数的组合有多少种
    params:
        array->解所属范围
        n->自变量个数
        target->因变量
    returns:
        answers->解的集合
        ans_len->解的个数
    
    """
    answers = []
    for i in itertools.combinations(array,n):
        if sum(i)==target:
            answers.append(i)
    ans_len=len(answers)
    return answers,ans_len
if __name__=='__main__':
    array=zs.copy()
    n=2
    target=30
    answers,ans_len=n_sum(array,n,target)
    print(answers)
    print(ans_len)
    

解法5

import itertools
def n_sum(array,n,target):
    """
    n个数加和等于某个数的组合有多少种
    params:
        array->解所属范围
        n->自变量个数
        target->因变量
    returns:
        answers->解的集合
        ans_len->解的个数
    
    """
    answers = []
    for i in itertools.combinations(array,n):
        if sum(i)==target:
            answers.append(i)
    ans_len=len(answers)
    return answers,ans_len
if __name__=='__main__':
    
    n=3
    target=30
    array=[i for i in range(target+1)]
    answers,ans_len=n_sum(array,n,target)
    print(answers)
    print(ans_len)