n=int(input())
div=2
output_num=[]
while n%div==0 and n>1:
    output_num.append(div)
    n=n//div
div+=1
a=[div%3-3,div%5]
while n>1 and div**2<=n:
    while n%div==0:
        output_num.append(div)
        n=n//div
    div+=2
if n>1:
    output_num.append(n)
print(' '.join(map(str,output_num)))

n = int(input())
factors = []  # 存储所有因子(质因子)
prime_factors = []  # 存储所有乘积使为n的质因子
# 找出所有因子
for i in range(2, n+1):
    if n % i == 0:
        factors.append(i)

# print(f"所有因子: {factors}")

for i in factors[:]:
    # 检查是否存在（除1和它本身以外的因数）整数能被i整除
    for j in range(2, i):  # 检查1到i-1是否有能整除i的数
        if i % j == 0:#若j能整除i，则i不是质数
            factors.remove(i)
            break

#计算质因子出现的次数
for p in factors:
    while n % p == 0:
        prime_factors.append(p)
        n //= p

for x in prime_factors:print(x,end=" ")

n = int(input())
list_prime = []
while n > 1:
    if n % 2 == 0:
        n = n // 2
        list_prime.append(2)
    else:
        break 
m = 3
max_len = n ** 0.5 + 1
while n > 1 and m < max_len:
    if n % m == 0:
        n = n // m
        list_prime.append(m)
    else:
        m += 2
if n > 2:
    list_prime.append(n)
print(" ".join(map(str,list_prime)))

笨办法

n = int(input())
a = []
i = 2
while n >= 2:
    if n % i == 0:
        a.append(i)
        n = n // i
    elif i < 1000:
        i += 1
    else:
        i = n
    # print(n, a,i)
print(*a)

n = int(input())
m = 2

while m**2 <= n:
    if n % m !=0:
        m +=1
    else:
        n = n // m
        print(m,end=' ')
print(n)

n=int(input()) if n<2: print(n)
list1=[] while n%2==0:
    list1.append(2)
    n=n//2 num=3 while num*num<=n: if n%num==0:
        list1.append(num)
        n=n//num else:
        num=num+2 if n>1:
    list1.append(n)
str1=" ".join(map(str,list1)) print(str1)

# sum = []
def _zhishu(s):
    for i in range(2,s+1):         
        if s%i == 0:
            s //= i
            print(i,end=" ")
            _zhishu(s)
            # sum.append(i)
            break
        elif i >= s**0.5:
            print(s,end=" ")  
            break       
    # return sum
a = int(input())
_zhishu(a)
# sum.sort()
# [print(sum[i],end=' ') for i in range(len(sum))]

用lst存储待输出的因子，设计求因子的函数divisor以及判断质数的函数isPrime
while循环判断lst内是否都是质数,全是质数就可以控制lst列表在一行内输出了：

import math

def isPrime(n): #判断是否为素数的函数 素数返回True 合数返回False
    n_root = int(math.sqrt(n))
    if n == 2 or n == 3:
        return True
    else:
        for i in range(2, n_root + 1):
            if n % i == 0:
                return False
    return True

def divisor(p): # 求数的因子的函数，返回两个和最小的因子 list
    p_root = int(math.sqrt(p))
    j = [1, p]
    for i in range(p_root, 0, -1):
        if p % i != 0:
            pass
        else:
            j[0] = i
            break
    j[1] = int(p/(j[0]))
    if j[0] == 1:
        l = list()
        l.append(j[1])
        return l
    else:
        return j

def bool_lst(lst):
    len_f = len(lst)
    i = 0
    for item in lst:
        if item:
            i += 1
    if i == len_f:
        return True
    else:
        return False

s = int(input()) # 接收输入的整数 int

lst = [s] # 存储待输出的质因子

len_lst = len(lst) # 待输出列表的长度 int

lst_flag = list() # 判断待输出列表是否全为质数的指标 全是质数则为True 默认不是质数 lst

for i in range(0, len_lst):
    lst_flag.append(isPrime(lst[i])) # 更新

lst_bool = bool_lst(lst_flag) # 更新 bool 

while (lst_bool == False): # 待输出因子列表中有合数
    for item in lst:
        s_new = divisor(item) # s_new是有两个因子的列表
        lst = lst + s_new # 在末尾加入两个因子
        lst.remove(item) # 删除被拆解的数
    len_lst = len(lst) # 更新len_lst
    lst_flag = list()
    for i in range(0, len_lst):
        lst_flag.append(isPrime(lst[i])) # 更新lst_flag
    lst_bool = bool_lst(lst_flag)

for item in lst:
    if item == 1:
        lst.remove(item)
lst.sort()

if lst_bool:
    print(" ".join(str(i) for i in lst)) # 控制列表在一行内输出

数学原理

代码实现中的细节

• n ** 0.5：在 Python 中，n ** 0.5用于计算n的平方根。例如，当n = 16时，n ** 0.5的结果是4.0。
• int(n ** 0.5)：由于range()函数只能接受整数参数，所以需要使用int()函数将n ** 0.5的结果转换为整数。这里的取整是向下取整，比如int(4.9)的结果是4。
• int(n ** 0.5) + 1：range()函数的结束值是开区间，即不包含结束值本身。所以为了确保能遍历到

• 的因数。

总结

import sys

n = int(input())

for i in range(2, int(n ** 0.5) + 1):  # 遍历所有可能的因数，直到 sqrt(n)
    while n % i == 0:  # 如果 i 是 n 的因子
        print(i, end=" ")  # 输出 i
        n = int(n / i)  # 更新 n 为商
if n > 2:  # 如果 n 本身是一个大于 2 的质数
    print(n)  # 输出 n