python核心编程2 第八章 练习

8–2. 循环. 编写一个程序, 让用户输入三个数字: (f)rom, (t)o, 和 (i)ncrement . 以 i
为步长, 从 f 计数到 t , 包括 f 和 t . 例如, 如果输入的是 f == 2, t == 26, i == 4 , 程序
将输出 2, 6, 10, 14, 18, 22, 26.

 f = int(input("From: "))
 t = int(input("To: "))
 i = int(input("Increment: "))
 for n in range(f, t+1, i):
     print(n, end=', ')

8–4. 素数. 我们在本章已经给出了一些代码来确定一个数字的最大约数或者它是否是一个
素数. 请把相关代码转换为一个返回值为布尔值的函数，函数名为 isprime() . 如果输入的是一个
素数, 那么返回 True , 否则返回 False .

 from math import sqrt

 def isprinme(num):
     if num == 1:
         return False
     for i in range(2, int(sqrt(num)) + 1):
         if num % i == 0:
             return False
     return True

 if __name__ == '__main__':
     num = int(input("输入数字: "))
     print(isprinme(num))

8–5. 约数. 完成一个名为 getfactors() 的函数. 它接受一个整数作为参数, 返回它所有
约数的列表, 包括 1 和它本身

 def getfactors(num):

     return [i for i in range(1, num+1) if num % i==0]

 if __name__ == '__main__':
     num = int(input("输入数字: "))
     print(getfactors(num))

8–6. 素因子分解. 以刚才练习中的 isprime() 和 getfactors() 函数为基础编写一个函
数, 它接受一个整数作为参数, 返回该整数所有素数因子的列表. 这个过程叫做求素因子分解, 它
输出的所有因子之积应该是原来的数字. 注意列表里可能有重复的元素. 例如输入 20 , 返回结果
应该是 [2, 2, 5] .

 from math import sqrt

 def isprinme(num):
     """质数"""
     if num == 1:
         return False
     for i in range(2, int(sqrt(num)) + 1):
         if num % i == 0:
             return False
     return True

 def getfactors(num):
     """约数"""
     return [i for i in range(1, num+1) if num % i==0]

 def prime_factors(num):
     """素因子"""
     res = []
     if isprinme(num):
         res = [1, num]
     else:
         temp = getfactors(num)
         for i in temp:
             if isprinme(i):
                 while num > 0 and num % i ==0:
                     res.append(i)
                     num //= i
     return res

 if __name__ == '__main__':
     num = int(input("输入数字: "))
     print(prime_factors(num))

8–7. 全数. 完全数被定义为这样的数字: 它的约数(不包括它自己)之和为它本身. 例如: 6
的约数是 1, 2, 3, 因为 1 + 2 + 3 = 6 , 所以 6 被认为是一个完全数. 编写一个名为 isperfect()

的函数, 它接受一个整数作为参数, 如果这个数字是完全数, 返回 1 ; 否则返回 0 .

 def getfactors(num):
     """约数"""
     return [i for i in range(1, num) if num % i==0]

 def isperfect(num):
     """完全数"""
     app = getfactors(num)
     if sum(app) == num:
         return 1
     return 0

 if __name__ == '__main__':
     num = int(input("输入数字: "))
     print(isperfect(num))

8–8. 阶乘. 一个数的阶乘被定义为从 1 到该数字所有数字的乘积. N 的阶乘简写为 N! .
写一个函数, 指定N, 返回 N! 的值.

 def factorial(N):
     if N == 1:
         return N
     return N * factorial(N-1)

 if __name__ == '__main__':
     N = int(input("输入数字: "))
     print(factorial(N))

8–9. Fibonacci 数列. Fibonacci 数列形如 1, 1, 2, 3, 5, 8, 13, 21, 等等. 也就是说,
下一个值是序列中前两个值之和. 写一个函数, 给定 N , 返回第 N 个 Fibonacci 数字. 例如, 第
1 个 Fibonacci 数字是 1 , 第 6 个是 8 .

 def sequence(num):
     if num == 1 or num == 2:
         return 1
     return sequence(num - 1) + sequence(num - 2)

 if __name__ == '__main__':
     num = int(input("输入数字: "))
     print(sequence(num))

8–10. 文本处理. 统计一句话中的元音, 辅音以及单词(以空格分割)的个数. 忽略元音和
辅音的特殊情况, 如 "h", "y", "qu" 等. 附加题: 编写处理这些特殊情况的代码.

 import string

 def count(sentence):

     words = sentence.split(' ')
     word_cnt = len(words)
     vowel_cnt, con_cnt = 0, 0
     for word in words:
         for ch in word:
             if ch in 'aeiouAEIOU':
                 vowel_cnt += 1
             elif ch in string.ascii_letters:
                 con_cnt += 1

     return ('元音:', vowel_cnt, '辅音:', con_cnt, '单词:', word_cnt)

 if __name__ == '__main__':
     sentence = input("Sentence: ")
     print(count(sentence))

8–12. （整型）位操作。编写一个程序，用户给出起始和结束数字后给出一个下面的表格，

分别显示两个数字间的十进制、二进制、八进制和十六进制。如果字符是可打印的ASCII字符，

也要打印出来，如果没有一个是可打印的就省略ASCII那一栏的表头。

 def format(start, end):
     print("十进制\t\t二进制\t\t八进制\t\t十六进制\t\tASCII"
           "\n-----------------------------------------------------------------")
     for i in range(start, end):
         if chr(i):
             asc = chr(i)
         else:
             asc = None
         print("%4s\t%10s\t%9s\t%10s\t%10s" % (i, bin(i), oct(i), hex(i), asc))

 if __name__ == '__main__':
     start = int(input("输入起始值："))
     end = int(input("输入结束值："))
     format(start, end)