Python—编程题

练习题

1、使用一行代码实现给定列表的奇偶数分离；list_a = [11, 22, 45,17,19,21,76,34,28,59]
答案：此处使用 列表推导式实现；

>>> 
>>> list_a = [11, 22, 45,17,19,21,76,34,28,59]
>>> part_js,part_os =[x for x in list_a if x%2==1],[x for x in list_a if x%2==0]
>>> part_js
[11, 45, 17, 19, 21, 59]
>>> part_os
[22, 76, 34, 28]
>>> 

2、编写程序，输出给定范围序列内的所有质数；
答案：此处使用 lamda表达式，all()函数以及 filter 函数实现；

start_n = int(input("请输入序列起始值："))
end_n = int(input("请输入序列终止值："))
iter_rt = filter(lambda x: all(x % y != 0 for y in range(2, x)), range(start_n, end_n))
list_rt = list(iter_rt)
print(list_rt)

# 结果输出
请输入序列起始值：20
请输入序列终止值：70
[23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67]

Process finished with exit code 0

---

此处也可以使用常规的循环方式实现：

start_n = 20
stop_n = 70
list_rt = list()
for x in range(start_n, stop_n + 1):
    flag = True
    for y in range(2, x):
        if x % y == 0:
            flag = False
            break

    if flag:
        list_rt.append(x)

print(list_rt)

3、编写程序输出前10个斐波那契数列；
答案：此处使用列表推导式实现；

fibo = [0, 1]
[fibo.append(fibo[-2] + fibo[-1]) for i in range(0,8)]
print(fibo)

# 结果输出
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Process finished with exit code 0

扩展：该题也可以考虑使用递归函数来实现，参数支持2种类型，一种按照序列数来输入，一种按照阈值范围来确定；
实现：按照递归函数和参数名称来赋值；

# coding=utf-8

fibo = [0, 1]

def queryFibo(count=0, stop_n=0):
    if count:
        if len(fibo) < count:
            fibo.append(fibo[-2] + fibo[-1])
            return queryFibo(count=count)
        else:
            return fibo
    elif stop_n:
        if (fibo[-2] + fibo[-1]) <= stop_n:
            fibo.append(fibo[-2] + fibo[-1])
            return queryFibo(stop_n=stop_n)
        else:
            return fibo


queryFibo(count=11)
print(fibo)
queryFibo(stop_n=60)
print(fibo)

# 输出结果
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Process finished with exit code 0

4、编写程序判断一个数字是否为阿姆斯特朗数(Armstrong)，
说明：如果一个n位正整数等于其各位数字的n次方之和,则称该数为阿姆斯特朗数，如下所示：

扩展：此处可以编码实现输出前固定项的Armstrong 或者在某个范围内符合Armstrong特征的值；

A：定义函数selectArmstrong 实现 Armstrong 值的判断

def selectArmstrong(input_n: int) -> bool:
    len_n = len(str(input_n))
    split_n = [int(x) ** len_n for x in str(input_n)]
    sum_n = sum(split_n)
    return True if input_n == sum_n else False

说明：这里使用到了列表推导式、三元表达式、列表求和操作；

B：定义函数 getArmstrong 获取 Armstrong值；要不输入最大边界值，要不输入符合的数据项个数；

def getArmstrong(count=0, start_n=1, stop_n=1):
    if count >= 1 and len(list_rt) < count:
        if selectArmstrong(start_n):
            list_rt.append(start_n)
        return getArmstrong(start_n=start_n + 1, count=count)

    elif start_n <= stop_n:
        if selectArmstrong(start_n):
            list_rt.append(start_n)
        return getArmstrong(start_n=start_n + 1, stop_n=stop_n)

说明：此处使用递归函数计算符合特殊的数值；

C：定义结果列表和 输出逻辑：

list_rt = list()
getArmstrong(count=12)
print(list_rt)

# 输出结果
[1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371]

Process finished with exit code 0

---

方法二：使用列表推导式实现，selectArmstrong函数公用；

list_rt = list()
start_n, stop_n = 11, 390
[list_rt.append(x) for x in range(start_n, stop_n) if selectArmstrong(x)]

print(list_rt)

# 结果输出
[153, 370, 371]

Process finished with exit code 0

5、编码实现一行代码展开列表 [[1,2],[3,4],[5,6]]，得到新的列表 [1,2,3,4,5,6]？
答案：列表推导式实现：

>>> 
>>> list_1=[[1,2],[3,4],[5,6]]
>>> list_2=[j for i in list_1 for j in i]
>>> list_2 
[1, 2, 3, 4, 5, 6]
>>>

6、编码实现 str_a = “ajldjlajfdljfddd”，去重并从小到大排序输出"adfjl"？
答案：先将字符串转换为集合，在转换为列表，最好排序；

>>> str_a = "ajldjlajfdljfddd" 
>>> list_a=list(set(str_a))
>>> list_a.sort()
>>> str_b="".join(list_a)
>>> str_b

说明：list.sort() 函数没有返回值，所以不能直接将其赋值给另外一个变量；

7、编码实现 字典 dict_a={“name”:“zs”,“age”:18,“city”:“深圳”,“tel”:“1362626627”} 根据键从小到大排序?
方式A：取出键值，排序后赋值给新的字典；

>>> 
>>> dict_a={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
>>> dict_new={}
>>> list_a=list(dict.keys())
>>> list_a.sort(reverse=False)
>>> for x in list_b:
...     dict_new[x]=dict[x]
... 
>>> dict_new
{'age': 18, 'city': '深圳', 'name': 'zs', 'tel': '1362626627'}

方式B：使用内置函数排序生成新的列表

>>> dict_a={"name":"zs","age":18,"city":"深圳","tel":"1362626627"}
>>> dict_b={}
>>> list_b=sorted(dict_a.items(),key=lambda i:i[0],reverse=False)
>>> list_b
[('age', 18), ('city', '深圳'), ('name', 'zs'), ('tel', '1362626627')]
>>> 
>>> for y in list_b:
...     dict_b[y[0]]=y[0]
... 
>>> 
>>> dict_b
{'age': 18, 'city': '深圳', 'name': 'zs', 'tel': '1362626627'}
>>>

8、编码 list=[2,3,5,4,9,6]，从小到大排序，不许用sort，输出[2,3,4,5,6,9]？
实现逻辑：递归将原列表最小值赋值给新列表；

list_aa=[22,11,33,55,22,77,99,88]
list_ll=[]

def sortList(var:list):

    if len(var)>0:
        min_n=min(var)
        list_ll.append(min_n)
        var.remove(min_n)
        sortList(var)

    return list_ll

print(sortList(list_aa))

9、代码举例说明如何交换两个数值？
代码实现：

>>> 
>>> num_1,num_2=11,22
>>> print(num_1,num_2)
11 22
>>> num_1,num_2=num_2,num_1
>>> print(num_1,num_2)
22 11
>>>

10、代码举例说明如何实现列表去重？
实现方式：先转为集合，再转为列表，代码如下：

>>> list_a=["aaa","bbb","aaa",11,22,33,33]
>>> set_a=set(list_a)
>>> print(set_a)
{33, 11, 22, 'aaa', 'bbb'}
>>> list_b=list(set_a)
>>> print(list_b)
[33, 11, 22, 'aaa', 'bbb']

11、字符串a = “not 404 found 张三 99 深圳”，每个词中间是空格，用正则过滤掉英文和数字，最终输出"张三 深圳"?

在这里插入代码片

12、x=“abc”,y=“def”,z=[“d”,“e”,“f”],分别求出x.join(y)和x.join(z)返回的结果？
代码实现：

在这里插入代码片

13、编码实现 n 的阶乘；
实现A：循环方式

def getfactor(stop_n):
    curr_v = 1
    for x in range(1, stop_n + 1):
        curr_v *= x
    return curr_v

实现B：递归方式
说明：递归方式有递归深度限制；

def getfactor(stop_n):
    if stop_n == 1:
        return 1
    elif stop_n > 1:
        return stop_n * getfactor(stop_n=stop_n - 1)

14、编码实现 1! + 2!+ 3! + …n! 之和；
实现A：递归计算，此处复用阶乘函数 getfactor；

def sumfactor(stop_n):
    if stop_n == 1:
        return 1
    elif stop_n > 1:
        return getfactor(stop_n) + sumfactor(stop_n - 1)

实现B：循环实现

def sumfactor(stop_n: int):
    sum_v, curr_v = 0, 1
    if stop_n == 1:
        sum_v = 1
    elif stop_n > 1:
        for x in range(1, stop_n + 1):
            curr_v *= x
            sum_v += curr_v

    return sum_v

说明：这种实现方式代码简单，而且就有些优雅了；

15、编码计算2个数的最大公约数和最小公共倍数；
答案；

在这里插入代码片

16、编写函数判断输入的年份是否为闰年；
说明：闰年的判断规则为 非100倍数的年份，可以被4整除；100倍数的年份可以被400整除；

def selectLeapYear(year_v: int):
    if (year_v % 4 == 0 and year_v % 100 != 0) or (year_v % 400 == 0):
        return True
    else:
        return False

17、编码实现键盘输入的值进行因式分解，如 120 = 2* 2* 235 ；
分析：进行分解时，当除数 大于 被除数的一半时无需再进行分解；

t = 120
i = 2
list_rt = list()
while True:
    if i >= (t / 2):
        list_rt.append(t)
        break
    if t % i == 0:
        list_rt.append(i)
        t /= i
    else:
        i += 1

    print(f"t={t},i={i}")

print(list_rt)

18、编码求解：假设有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
分析：列出每个月的兔子数值，发现类似于斐波那契数列，1,1,2,3,5,8,13,21…

list_rt = [1, 1]

def getfibo(month_n: int):
    if month_n <= 2:
        return list_rt[month_n - 1]
    elif len(list_rt) >= month_n:
        return list_rt[-1]
    else:
        list_rt.append(list_rt[-2] + list_rt[-1])
        return getfibo(month_n)

19、编码计算一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在
第10次落地时，共经过多少米？第10次反弹多高？
分析：

# coding=utf-8

def totalPath(level):
    sum_v = 100
    curr_l = 100

    if level == 1:
        return sum_v, curr_l / 2
    else:
        for x in range(2, level + 1):
            sum_v += curr_l
            curr_l /= 2

    return sum_v, curr_l/2


print(totalPath(4))