思路

判断参数是否合法：

1. 至少需要两个参数（判断长度是否大于2）
2. 只接受正整数（遍历所有参数》判断类型是否为整型 是否小于等于零）
3. 不符合：返回提示信息 <字符串>
4. 符合：返回False

# 参数输入判断是否合法
def _notStd(num, length=2, positive=True):
    if len(num) < length:
        return "至少需要两个参数"
    for x in num:
        if type(x) != int:
            return "只支持整数"
        if positive and x <= 0:
            return "只支持正整数"
    else:
        return False

最大公约数：

1. 最小的参数是否可直接成为结果（从小到大排序 结果设为最小值）
2. 遍历每个参数并判断结果是否能整除
   1. 判断参数模结果不为零时 将模数赋值给结果，进行迭代
3. 结果可以整除所有参数（如果取模都为零，则运行else返回结果）

# 最大公约数
def gcd(*num, result=0):
    # 判断数值是否合法
    judge = _notStd(num)
    if judge:
        return judge
    if result == 0:  # 首次调用
        num = sorted(list(num))  # 从小到大排序
        result = num[0]  # 默认结果为最小值
    for i in num:
        if i % result != 0:  # i模结果不为零
            result = i % result  # 结果设为这两个值的模
            return gcd(*num, result=result)  # 递归
    else:
        return result  # 返回最小值

最小公倍数： 

1. 最大的参数是否可直接成为结果（从小到大排序 结果设为最大值）
2. 遍历每个参数并判断结果是否能整除
   1. 判断参数模结果不为零时 算出此结果与此参数的最小公倍数（将结果与此参数的最小公倍数的积赋值给结果），进行迭代
3. 结果可以整除所有参数（如果取模都为零，则运行else返回结果）

# 最小公倍数
def lcm(*num, result=0):
    # 判断数值是否合法
    judge = _notStd(num)
    if judge:
        return judge
    if result == 0:  # 首次调用
        num = sorted(list(num))  # 从小到大排序
        result = num[-1]  # 默认结果为最大值
    for i in num:
        if result % i != 0:  # 最大值模i不为零
            result = i * result // gcd(i, result)  # 最大值设为这两个数的最大公倍数
            lcm(*num, result=result)  # 递归
    else:
        return result  # 返回最大值

是否为素数： 

1. 定义内置函数 是否为素数
   1. 从2遍历到参数-1
   2. 不能整除返回False
   3. 都能整除 运行else 返回True
2. 长度为1时：通过下标将包含信息的字符串输出（False下标为0，True下标为1）
3. 长度不为1时：遍历运行每个

# 对素数进行归纳
def isSu(*num):
    # 判断数值是否合法
    judge=_notStd(num, length=1)
    if judge:
        return judge

    # 判断是否是素数
    def su(x):
        for i in range(2, x):
            if x % i == 0: return False
        else:
            return True
    # 一个参数时直接输出判断结果
    if len(num) == 1:
        return ["合数", "素数"][su(num[0])] # False=0 True=1
    # 多个参数对参数进行归纳
    else:
        result = {"素数": [], "合数": []}
        for x in num:
            if su(x):
                result["素数"].append(x)
            else:
                result["合数"].append(x)
        return result

源码

# 参数输入判断是否合法
def _notStd(num, length=2, positive=True):
    if len(num) < length:
        return "至少需要两个参数"
    for x in num:
        if type(x) != int:
            return "只支持整数"
        if positive and x <= 0:
            return "只支持正整数"
    else:
        return False


# 最大公约数
def gcd(*num, result=0):
    # 判断数值是否合法
    judge = _notStd(num)
    if judge:
        return judge
    if result == 0:  # 首次调用
        num = sorted(list(num))  # 从小到大排序
        result = num[0]  # 默认结果为最小值
    for i in num:
        if i % result != 0:  # i模结果不为零
            result = i % result  # 结果设为这两个值的模
            return gcd(*num, result=result)  # 递归
    else:
        return result  # 返回最小值


# 最小公倍数
def lcm(*num, result=0):
    # 判断数值是否合法
    judge = _notStd(num)
    if judge:
        return judge
    if result == 0:  # 首次调用
        num = sorted(list(num))  # 从小到大排序
        result = num[-1]  # 默认结果为最大值
    for i in num:
        if result % i != 0:  # 最大值模i不为零
            result = i * result // gcd(i, result)  # 最大值设为这两个数的最大公倍数
            lcm(*num, result=result)  # 递归
    else:
        return result  # 返回最大值


# 对素数进行归纳
def isSu(*num):
    # 判断数值是否合法
    judge=_notStd(num, length=1)
    if judge:
        return judge

    # 判断是否是素数
    def su(x):
        for i in range(2, x):
            if x % i == 0: return False
        else:
            return True
    # 一个参数时直接输出判断结果
    if len(num) == 1:
        return ["合数", "素数"][su(num[0])] # False=0 True=1
    # 多个参数对参数进行归纳
    else:
        result = {"素数": [], "合数": []}
        for x in num:
            if su(x):
                result["素数"].append(x)
            else:
                result["合数"].append(x)
        return result


if __name__ == "__main__":  
    print(gcd(6, 8))
    print(gcd(63, 18))
    print(lcm(15, 6, 3))
    print(lcm(24, 28))
    print(isSu(3, 8, 6, 4, 9))
    print(isSu(3))