python语言一个正整数的因子怎么求 python求正整数的所有约数

一、最小公倍数算法

任务：编写一个能计算给定的所有正整数的最小公倍数的小程序。

相关知识

为了完成本关任务，你需要掌握：

1. 如何求任意两个正整数的最大公约数。
2. 如何求任意两个正整数的最小公倍数。

如何求任意两个正整数的最大公约数

最大公约数(GCD, Greatest Common Divisor)，也称最大公因数、最大公因子，指两个或多个整数共有约数中最大的一个。

比如数12和数18的最大公约数是6，因为12的约数有1、2、3、4、6、12，而18的约数有1、2、3、6、9、18，通过比较，显然6是数12和数18的最大公约数。

通过上述过程，显然我们可以通过枚举这两个数的所有约数，考虑这两个数共有的约数，然后选择最大的就是这两个数的最大公约数，因为一个数的约数必然是不大于该数的，所以我们可以通过枚举不超过这两个数中的最大者的正整数，来达到上述效果，具体代码如下述所示：

def gcd_1(x, y):
    ed = max(x, y)+1
    divisor = 1
    for i in range(2, ed):
        if x % i == 0 and y % i == 0:
            divisor = i
    return divisor

其实在古代就有能求解出最大公约数的算法了，《九章算术》是中国古代的数学专著，其中的“更相减损术”就可以用来求两个数的最大公约数，原文是：“可半者半之，不可半者，副置分母、子之数，以少减多，更相减损，求其等也。以等数约之。”大致所描述的算法步骤是：

• 任意给定两个正整数；判断它们是否都是偶数。若是，则用2约简；若不是则执行第二步。
• 以较大的数减较小的数，接着把所得的差与较小的数比较，并以大数减小数。继续这个操作，直到所得的减数和差相等为止。
• 第一步中约掉的若干个2与第二步中最后得到的差（或减数）的乘积就是所求的最大公约数。

实际编程中，我们可以省略第一步，这样第二步最后得到的差（或减数）就是这两个数的最大公约数，其具体实现如下述代码所示：

def gcd_2(x, y):
    while True:
        if x < y:
            x, y = y, x
        elif x == y:
            return x
        x -= y

尽管前面已经介绍了两种求最大公约数的方法，但实际生活中，我们更倾向于使用辗转相除法来求解任意两个正整数的最大公约数，以求解30和12的最大公约数为例，按gcd_2代码，其过程为：

30 - 12 = 18 -> 18 - 12 = 6 -> 12 - 6 = 6

最后因为减数和差相等，即6 - 6 = 0，故6就是30和12的最大公约数，仔细观察上述过程，我们可以发现第一步和第二步实际上就是被减数30减了2次12，然后在第三步，用上次计算的余数6继续与12进行比较，显然，我们可以通过整数求余运算直接一步求得30和12的余数6，此时余数绝对是比除数小的，那么则将除数代替被除数的位置，余数代替除数的位置，然后重复上述过程，直至余数为0，那么此时的除数就是原来两个数的最大公约数了。上述过程用递归方式实现的话，代码是非常简短的，具体代码如下：

def gcd(x, y):
    return x if y == 0 else gcd(y, x%y)

 最后，推荐大家也去实现下求解任意两正整数的最大公约数的非递归版本。

如何求任意两个正整数的最小公倍数

几个数共有的倍数叫做这几个数的公倍数，其中除0以外最小的一个公倍数，叫做这几个数的最小公倍数（LCM，Least Common Multiple）。

如3和7的最小公倍数是21，因为不存在一个比21还小的正整数既是3的倍数，也是7的倍数。

显然对任意两个正整数a和b，a*b必是他们的公倍数。假设g为a和b的最大公约数，那么a,b, 可以分别写成一个正整数与他们最大公约数的乘积的形式，即a = p * g，b = q * g，那么显然c = p * q * g，是a和b的一个公倍数，而且是最小公倍数，因为p和q必定不共有大于1的公约数，所以若减小p、q、g这三个任意一个数的话，都不能使其乘积还是a和b的倍数。

题目：

根据提示，在右侧编辑器补充代码，计算并输出给定的所有正整数的最小公倍数。

class Solution():
    
	def get_lcm(self, x):
		'''
		:type x: list
		:rtype : int
		'''
		#请在此添加代码，实现求出给定的所有正整数的最小公倍数，并将其返回
		#********** Begin *********#
		def gcd(x,y):#求最大公约数
            return x if y==0 else gcd(y,x%y)
        def lcm(x,y):
            return x*y/gcd(x,y)#求最小公倍数
        result=x[0]
        for i in range(len(x)-1):
            x[i+1]=lcm(x[i],x[i+1])
            result=max(x[i+1],result)
        return int(result)
		##********** End **********#
		pass

二、输出指定范围内的素数

任务描述

本关任务：编写一个能输出指定范围内的素数的小程序。

相关知识

为了完成本关任务，你需要掌握：

1. 如何判断一个正整数是否是素数。

如何判断一个正整数是否是素数

素数（Prime Number），又称质数，一个大于1的自然数，除了1和它自身外，不能整除其他自然数的数叫做质数；否则，称为合数（Composite Number）。1既不是素数，也不是合数。

如2、3、5、7、11都是素数，因为找不到除了1和其本身之外的约数；而4、6、8都是合数，因为4可以整除2，6可以整除2和3，8可以整除2和4。

根据上述定义，我们很容易写出判断一个素数是否是素数的代码：

def is_prime_1(x):
        if x == 1:
            return False
        for i in range(2, x):
            if x % i == 0:
                return False
        return True

假设一个正整数a，则其可以被写成任意两个正整数之积，即a = p * q，假设p < q，那么正整数p和q都是a的约数，注意到，如果我们知道p是a的约数，那么可以通过q = a / p快速求得另外一个约数q。所以，我们在判断质数的时候，只需要枚举2到不大于sqrt(a)的正整数即可。

虽然通过上述方法，已经能让我们在根号级别的复杂度内判断一个正整数是否是素数，但如果我们要判断很多个数是否为素数呢？是否每次都需要枚举int(sqrt(a)+1)个数呢？回到我们最初的起点，我们之所以要枚举这些数，就是想找出原数的约数。然后除1外，任何一个正整数都能写成多个素数的乘积的形式，那么我们枚举特定范围内的所有素数，也能达到相同的效果，而且在判断多个正整数是否是素数的时候，我们只需要枚举更少的质因数与其比较，大家可以看下下面不同区间内的素数统计结果：

从上图的统计结果我们可以发现，当区间越来越大，里面的素数个数和区间内所有数字的个数差距也越来越大。所以，我们用区间内的素数去判断一个整数是不是素数，比较的次数将更少。

而求不超过某个正整数x内的所有素数，有一个著名的算法——埃拉托斯特尼筛法。其算法描述为：

• 先用一个数组vis，把不大于该正整数x的所有正整数标记为0，表示没有访问。
• 然后从第一个素数2开始遍历整个区间，如果当前访问的数没有访问过，则可以认为它是一个素数，那么就将它在该区间内所有的倍数全部标记为已访问，这样就保证外部的循环发现的没有访问过的数都是素数。

其具体实现如下述代码所示：

def sieve(x):
        vis = [0 for i in range(x+1)]
        prime_table = []
        for i in range(2, x+1):
            if vis[i] == 0:
                prime_table.append(i)
                for j in range(i*2, x+1, i):
                    vis[j] = 1
        return prime_table

然而，除了上述筛法，还有其他高效的筛法，比如欧拉筛法：

def ouler(x):
        vis = [0 for i in range(x+1)]
        prime_table = []
        ln = 0
        for num in range(2, x+1):
            if vis[num] == 0:
                prime_table.append(num)
                ln += 1
            for j in range(ln):
                if num * prime_table[j] > x:
                    break
                vis[num * prime_table[j]] = 1
                if num % prime_table[j] == 0:
                    break
        return prime_table

题目：

第一行输入正整数n，表示测试样例组数，接下来输入n行， 每行输入两个正整数a和b，要求输出a和b之间（包括a和b）所有的素数，保证a<b，且b不超过10^7

测试输入： 2 30,100 999670,1000000

预期输出： [31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97] [999671, 999683, 999721, 999727, 999749, 999763, 999769, 999773, 999809, 999853, 999863, 999883, 999907, 999917, 999931, 999953, 999959, 999961, 999979, 999983]

class Solution():

    def solve(self, l, r):
        #:type l, r: int
        #:rtype : list
        #请在此添加代码，实现求得[l, r]范围内的所有素数，并将其返回

        #使用埃拉托斯特尼筛法：
        vis=[0 for i in range(r+1)]
        prime_table=[]
        for i in range(2,r+1):
            if vis[i]==0:
                for j in range(i*2,r+1,i):
                    vis[j]=1
                if i>=l:
                    prime_table.append(i)
        return prime_table
            
          

        #********** End *********#

三、Python对文件的操作

Python对文件的读写操作

通常，Python对文件的操作大致可分为下列三步：

• 通过open函数打开指定文件，并且获得文件的句柄。
• 通过上一步的文件句柄，对文件进行读(read)、写(write)操作。
• 通过文件句柄的close函数关闭文件句柄。

其中，对于open函数，我们至少得知道其前2个参数以及encoding参数的含义（其他参数在生活中使用得并不多，有兴趣的可以查阅相关文档）。

• 第一个参数是文件路径，这个地方需要注意下使用的是绝对路径还是相对路径。
• 第二个参数是指明本次操作的模式，常用的可分为“读”、“写”和“读写”3种，分别对应字母r、w和r+(w+)。如果要对文件进行读操作，即指明模式值为r，那么必须保证该文件路径正确（即文件存在），并且禁止程序对该文件进行写操作；如果对文件进行写操作，即指明模式值为w，那么python会打开这样一个文件，并且清空里面的内容，如果不存在，则会自动创建，同时，不允许程序对该文件进行读操作。r+和w+的虽说既可以进行读操作，又可以进行写操作，但是前者打开后文件内容还在，后者打开文件的同时清空了里面的数据，所以有关w的操作请慎用！如果我们想在文件内容末位添加数据，可以指明模式值为a，其他更多参数可以参考下图。
• 在python3中，程序执行环境采用的是Unicode编码，而网络上还有诸如UTF-8、ASCII和UTF-16等等编码格式，对于一种编码写入的数据，必须要用同样的编码方式进行解码并读取数据，否则就会出现乱码的情况，一般来说这个参数是可选参数，我们不必刻意去设置，但是当我们有某种需求，特别是爬虫工作者，这个编码可真的是一个要特别注意的问题。

打开文件后，我们即可通过read和write函数对文件进行读写，read函数是一次性将文件中的所有内容都读取出来，但如果文件内容一大，这对计算机可是一个不小的负荷，更何况我们往往一次不需要这么多数据。为解决上述问题，我们可以用readline函数去一行一行地读取文件。读操作还有一个函数readlines，他是将文件所有数据按行读取出来形成一个list，效果和read一样，不过这里将其按行顺序处理了。

示例程序：

'''
    假设文件ceshi.txt，内容如下：
    python
    读写文件
    原来可以这样玩
'''
    #获取文件句柄
    f = open("ceshi.txt")
    #一次性读取文件内容
    print(f.read())
    #使用完一定要记得关闭句柄
    f.close()

示例输出:

python
读写文件
原来可以这样玩

写操作的话主要通过write函数完成，使用与上述read函数的调用类似，这里不再演示，不过这里可以把需要写的内容直接作为write函数的参数传递过去即可，但要注意的是，用写模式打开文件，会清空文件原有的数据！

Python内置函数sorted的使用

给定一个数组，对其按照某种顺序排序，比如将数字从小到大排序，我们很容易写出一个冒泡排序的代码：

ls1 = [1, 5, 4, 3, 2]
def bubble_sort(ls):
    for i in range(len(ls)-1):
        for j in range(len(ls)-i-1):
            if ls[j] > ls[j+1]:
                ls[j], ls[j+1] = ls[j+1], ls[j]
    return ls

我们知道还有诸如快速排序、堆排序更加快的排序方法，而且书写这么一个排序算法代码量又比较大，这时候我们可以考虑用python中内置的排序函数——sorted函数，我们只需要提供排序关键字的转换函数即可，如我们想对Alice、Bob和qwer这四个字符串按长度大小从小到大排序，可以这么写：

ls = ['Alice', 'Bob', 'qwer']
def func(key):
    return len(key)
print(sorted(ls, key=func))

示例输出:

['Bob', 'qwer', 'Alice']

如果熟悉lambda表达式的话，简单的排序规则将会表现得更加简洁，如上述代码可以表示为sorted(ls, key=lambda x:len(x))

编程要求

实现将file_1和file_2文件中的数字按从小到大的顺序排序，并将结果写入file_3文件中。

测试输入：

second_task/step4/test_a_1.txt

second_task/step4/test_b_1.txt

second_task/step4/output/out.txt

预期输出（学员只需完成将结果写入文件中的操作即可）：

class Solution():

    def solve(self, file_1, file_2, file_3):
        '''
        :type file_1, file_2, file_3: str
        :rtype : None
        '''
        #请在此添加代码，实现将文件file_1和file_2中的数字按从小到大的顺序，写入文件file_3中
        
        #********** Begin *********#
        a=[]
        f1 = open(file_1)
        temp=f1.read().strip().split('\n')
        #strip()方法去除首尾空格
        #split('\n')：按回车分开，返回列表
        a.extend(temp)
        #用extend（）将temp中的元素添加到a里，不可以用append（）
        f2 = open(file_2)
        temp=f2.read().strip().split('\n')
        a.extend(temp)
        a = sorted(int(i) for i in a)#转换成int进行排序
        with open(file_3,'w') as f3:
            for line in a:
                f3.write(str(line)+'\n')#转换成str存入f3 
        return f3
        ##********** End *********#

参考：《Python编程从入门到实践》