python编程题集锦_软件测试工程师

入行软件测试，学习期间免费(不贷款)，就业后再收费，包就业，不就业不收费。咨询加V：zsy1560707
#!/usr/bin/env python
# 1.获取1-100之间的素数(大于1的并不只能被1和本身整数的数叫素数，也叫质数)
list = [] #构造1-100的数字列表
for i in range(1,101):
    list.append(i)
print(list)
# 判断素数
for i in range(1,101):
    for j in range(2,i): # 遍历2开始到i-1之间的数字j，如果i能被数字j整数，则i不是素数
        if i%j==0:
            list.remove(i) # 移除非素数
            break
print(list) #打印结果

'''
2.给定一个整数 num，从 1 到 num 按照下面的规则返回每个数运算结果
如果num被 3 整除，返回 'Fizz'。
如果num被 5 整除，返回 'Buzz'。
如果num能同时被 3 和 5 整除，返回 'FizzBuzz'。
如果num既不能被 3 也不能被 5 整除，返回这个数字的字符串格式
'''
# 定义函数
def f(num):
    dict = {}
    for i in range(1,num+1):
        if i%3==0:
            dict[i]='Fizz'
        if i%5==0:
            dict[i]= 'Buzz'
        if i%3==0 and i%5==0:
            dict[i]= 'FizzBuzz'
    return dict

# 调用函数
print(f(100))

# 3.选择排序(升序)：关注最小元素
'''
选择排序：
原理：
1.第一个元素看成是最小值，然后和下一个值比较，谁小，谁就放到最左边。这样比一圈。
2.然后在剩下元素里面继续这样比较，得到第二个最小值且放到最左边(第二个位置)
实现：
1.双层for循环，外循环需要循环n-1次。
2.第一次外循环，内循环需要循环n-1次，内循环次数是逐减的。
'''
# 定义函数
def select_sort(list):
    for i in range(list.__len__()-1):  # 外循环4次
        for j in range(i+1, list.__len__()):  # 一开始，内循环4次
            if list[i] > list[j]:
                # i = 0           # i=1
                # j = 1,2,3,4     # j=2,3,4
                list[i], list[j] = list[j], list[i]  # 交换位置
                pass
    return list
# 调用函数
list = [1, 5, 3, 18, 8]
print( select_sort(list=list) )


# 4.冒泡排序(升序)：关注最大元素
'''
冒泡排序:
原理：
1.相邻元素比较，谁大，谁放右边，这样比一圈，最右边的值就是最大值。
2.剩下元素里面，继续这样比，第二个最大值放到最右边(倒数第二位)
实现：
1.双层for循环，外循环需要循环n-1次。
2.第一次外循环，内循环需要循环n-1次，内循环次数是逐减的。
'''
# 定义函数
def bubble_sort(list):
    for i in range(list.__len__()-1):  # 外循环4次
        for j in range(list.__len__()-1-i):  # 一开始，内循环4次
            if list[j] > list[j+1]:
                # 相邻元素比较，如果左边的大，则互换位置，保证右边的值要大
                list[j], list[j+1] = list[j+1], list[j]
    return list
# 调用函数
list = [5,4,1,3]
print( bubble_sort(list=list) )


# 5.在有序数组中采用“二分法”查找某元素的位置。
# (系统提供了list.index()方法来查找元素的索引)
def halfSearch(arr,key):
    """arr为传入的数组，key为需要查找的元素 """
    min_index = 0
    max_index = len(arr)
    if key in arr:
        while True:
            mid_index = int((min_index + max_index)/2) #中位数
            if key >arr[mid_index]: # 如果查找的数在中位数的右边
                min_index = mid_index + 1
            elif key # 如果查找的数在中位数的左边
                max_index = mid_index - 1
            else: # 否则key = arr[mid_index]
                return  mid_index
    else:
        return -1; # 自定义-1代表不存在该元素

# 调用函数
arr = [1,4,6,9,14]
key = 9
print(f'元素{key}的索引：', halfSearch(arr,key))

# 6.定义递归函数求n的阶乘之和。比如当n=4, 求 4!+3!+2！+1！之和
#递归求阶乘
def f(x):
    if x == 1:
        return 1
    return f(x-1)*x

#递归求和
def fn(x):
    if x==1:
        return 1
    # def f(x): # 在函数体定义一个函数
    #     if x == 1:
    #         return 1
    #     return f(x - 1) * x
    return fn(x-1)+f(x)

#调用函数
print(fn(3))

'''
7.给定一个整型数组：
返回最大前后差（数组中位置靠后的数 - 数组中位置靠前的数）

比如对于数组[3,6,9,7,10,1,2,5]
10-3是一个前后差，为7
5-1是一个前后差，为4
而10-1则不是一个前后差，因为10的位置在1的前面。
故本数组最大前后差为7。
如果本数组为单调递减数组，则返回0。
数组长度介于1-100000之间。
程序的运行时间应该尽可能短。
'''
# 定义函数
def max_diff(list):
    list2 = [] # 封装差值
    # 双层for循环，获取当前元素和右边所有元素的差值
    for i in range( list.__len__() ):
        for j in range(i+1, list.__len__()):
            val = list[j] - list[i] # [3,6,9,7,10,1,2,5]
            list2.append(val) # 收集差值

    # 判断差值是否全为负数
    count = 0 # 统计差值为负数的数量
    for e in list2:
         if e < 0:
             count = count + 1
    if count == list2.__len__():
        return 0 # 为单调递减列表
    else:
        list2.sort() # 排序：默认为升序
        return list2[list2.__len__()-1] # 最后一个元素是最大的
# 调用函数
list = [3,6,9,7,10,1,2,5] # len = 8
print( max_diff(list) ) # 7
'''
8.一个班级有N名同学，每个同学有编号id、身高height、体重weight。
要求同学们按身高从低到高进行排序，并计算所有同学的体重的和
要求：
1、闭卷，30
分钟
2、使用熟悉的编程语言实现题目要求，定义一个函数、输入一个数组（列表），
打印出根据身高从低到高排序后的结果，返回体重的和，最低要求实现体重的和。
数组格式为：
[
    {
        "id": 1,
        "height": 175,
        "weight": 60
    },
    {
        "id": 2,
        "height": 160,
        "weight": 54
    },
    {
        "id": 3,
        "height": 181,
        "weight": 64
    },
]
举例：
上述数组排序后的结果为：
[{"id": 2, "height": 160, "weight": 54}, {"id": 1, "height": 175, "weight": 60},
 {"id": 3, "height": 181, "weight": 64}, ]
体重和为178
'''
# 定义函数
def sortKeys(students):
    students_new = sorted(students, key=lambda student: student["height"])
    print(students_new) # 打印排序后的学生列表
    # 获取体重之和
    sum = 0
    for student in students_new:
        sum = sum + student["weight"]
    return sum

# 调用函数
students = [
    {"id": 1,
     "height": 175,
     "weight": 60
     },
    {"id": 2,
     "height": 160,
     "weight": 54
     },

    {"id": 3,
     "height": 181,
     "weight": 64
     },
]
print( sortKeys(students) ) # 打印返回的“体重和”

# 9.定义一个数组，只包含正整数， 返回该数组中重复次数最多的前N个数字，返回结果按重复次数，从多到少降序排列。
list1 = [1,2,3,22,1,2,3,1,1,1,2,22,22,22]
# 定义函数
def countN(N):
    import  operator
    a = {}
    list2 = []
    for i in list1:                  #for 的 i 是 list1[0--list1.len-1]
        if list1.count(i)>=1:
            a[i] = list1.count(i)   #判断1的重复次数是否大于1
                                    #是的话就a[1]=5    a[1:5]
                                    #进行判断2的重复次数是否大于1
                                    #是的话就a[2]=3   a[2:3]

    b=sorted(a.items(),key=operator.itemgetter(1),reverse= True)#这里改为按照item的第二个字符排序，即value排序
    for j in b:
        list2.append(j[0])    #获取已经排序好的列表进行导入到list2列表中
    print(list2)
# 调用函数
countN(4)

# 10.定义一个方法，判断字符串中的括号数量是否匹配。比如：(hello(welcome(come to)))
def matchs(str):
    #记录左右括号数量的变量
    left=0
    right=0
    #遍历字符串中的字符
    for i in str:
        if i=="(":
            left=left+1
        if i==")":
            right=right+1
    #数量匹配则返回True，否则False
    return left==right

#调用函数
str = '(hello(welcome(come to)))'
print(matchs(str))