自动化测试常见Python算法题&答案

本篇整理了上一篇Python算法题的答案，因为后面自己接触到了lambda，reduce,filter等函数，所以部分题目写了两种或者多种实现方式。

算法题&答案如下：

# ----------------公司一----------------
#第一道题:
str001 = "my love is you do you konw it ? do you love me ?"
list001 = str001.split(' ')
print(list001)
print(str001.count(' '))
print("单词的总数为%s" % (len(list001)))  #14
print("空格的总数为%s" % str001.count(' '))   #13
print("you的总数为%s" % (list001.count('you'))) #3
# 解释一下整个程序的过程?
    # 以空格为分隔符，将字符串转化成列表，分别统计单词、空格、you的数量。

#第二道题：一个数的阶层运算，求结果
def func001(a):
    if a == 1:
        return 1
    else:
        return a*(func001(a-1))

result = func001(5)
print(result)   #120

#第三道题目：实现一个数字的斐波那切数列
# 8 的菲波那切数列数列为： [1,1,2,3,5,8,13,21]
def func001(a):
    list001 = []
    j = 1
    for i in range(1,a+1):
        if i == 1 or i == 2:
            j == 1
        else:
            j = list001[i-2] + list001[i-3]
        list001.append(j)
    print("%s的菲波那切数列是%s" %(a,list001))
func001(8)

#第四道题(机试题)：将一个列表的负数给删掉，然后再返回最终的列表
#错误代码
"""
def listHandle(a):
    for i in a:
        if i < 0:
            a.remove(i)
    return a
list001 = [1,3,-3,5,-4,-6,10]
print(listHandle(list001))
"""
#正确代码
def listHandle(a):
    i = 0 
    b = a.copy()  # 或者b = a[:]  ; 或者 b = copy.copy(a)
    while i < len(a):
        if a[i] < 0:
            a.pop(i) #  或者a.remove(a[i])
        else:
            i +=1   #正数才需要加1,负数被删除导致后面的数顶替上来,索引不变，继续原索引判断
    print("列表%s剔除掉负数后的新列表为%s" %(b,a))
list001 = [1,3,-3,5,-4,-6,10]
listHandle(list001)

# ----------------公司二----------------
"""
    机试题1：
        读取某个json文件，取出某个key下面所有的值(列表嵌套字典)
        再拿到嵌套字典里面的value值，然后以第一个value值为key，第二个value值为value追加到新的字典内
        新字典格式{"fe5f5a07539c431181fc78220713aebein01":"zyy1","73ea2bf70c73497f89ee0ad4ee008aa2in01","zyy2"}
        json文件内容：
            {
            "configuration_id": "cf49bbd7d2384878bc3808733c9e9d8bpr01",
            "configuration_name": "paramsGroup-bcf9",
            "apply_results": [
                {
                    "instance_id": "fe5f5a07539c431181fc78220713aebein01",
                    "instance_name": "zyy1"
                },
                {
                    "instance_id": "73ea2bf70c73497f89ee0ad4ee008aa2in01",
                    "instance_name": "zyy2"
                }
            ],
            "success": false
        }

"""

import json

# 方式二：多行实现(循环)
with open('transfer.json', 'r') as fp:
    content = fp.read()
theDict = json.loads(content)  # json字符串转字典
theList = theDict.get("apply_results")  # 获取字典内的列表
List01 = []
for i in theList:
    List01.append(i.values())       # values()：将字典的value追加到列表内并返回
print(List01)
theDict = dict(List01)     # 列表转换成字典
print("the final dict is ", theDict)

# 方式二：单行实现
with open('transfer.json', 'r') as fp:
    theList = json.loads(fp.read()).get("apply_results")
the_dict = dict(map(lambda x: x.values(), theList))
print("the final dict is ", the_dict)


"""
    机试题2：
        测试两个接口，一个post，一个为get
        用Python脚本写出断言httpCode ,msg 等信息的相关代码
"""
import unittest
import json
import requests
class InterfaceTest(unittest.TestCase):
    def setUp(self):
        pass

    def test_get(self,url,param):
        try:
            response = requests.get(url,param)
            response = json.dumps(response)
            #断言
            self.assertEqual(response['status_code'],200,msg='status_code不等于200')
            self.assertEqual(response['msg'],'登录成功',msg='登录失败')
        except AssertionError as e:
            print('%s' %e)

    def test_post(self,url,param):
        header = {'Content-Type':'application/json'}
        try:
            response = requests.post(url,param,headers=header)
            response = response.dumps(response)
            #断言
            self.assertEqual(response['status_code'],200,msg='status_code不等于200')
            self.assertEqual(response['msg'],'登录成功',msg='登录失败')
        except AssertionError as e:
            print('%s' %e)

    def tearDown(self):
        pass

if __name__ == "__main__":
    unittest.main()

# ----------------公司三----------------
"""
    面试时间：2019/11/26
    面试题1：1加到N的阶层之和,比如N=4, result = (1! + 2! + 3! + 4!)

"""

# 方式一：借助reduce、lambda、append函数
the_list = []
def countResult(a):
    for i in range(1, a + 1):
        result = reduce(lambda x, y: x * y, range(1, i + 1))
        the_list.append(result)
    print(the_list)
    return sum(the_list)
print(countResult(5))

# 方式二：借助reduce、lambda函数
result = 0
temp = 0
def countResult(a):
    for i in range(1, a + 1):
        global result
        global temp
        temp = reduce(lambda x, y: x * y, range(1, i + 1))
        result += temp
    return result
print(countResult(5))

# 方式三：传统循环
result = 0
temp = 1
def countResult(a):
    for i in range(1, a + 1):
        global result
        global temp
        for j in range(1, i + 1):
            temp = temp * j
        result += temp
        temp = 1
    return result

print(countResult(5))


# ----------------公司四----------------
"""
    面试题1：实现一个数字的反转，比如输入123，输出321
"""

# 方式一：
a = input("请输入数字：")
a = a[::-1]
print(a)

# 方式二：
a = 12345
theList = []
for i in str(a):
    theList.append(i)
theList.reverse()
a = "".join(theList)
a = int(a)
print(a)


"""
    面试题2：用awk命令将日志里面的时分秒，日期取出来
    日志文件内容：
    181014 21:48:01 mysqld_safe Starting mysqld daemon with databases from /var/lib/mysql 2019-12-13
    181014 21:48:02  InnoDB: Initializing buffer pool, size = 8.0M 2019-12-13
    181014 21:48:02  InnoDB: Completed initialization of buffer pool 2019-12-13
"""
# 这道题当时没做对，想到取时间/日期，第一反应想到的是用正则取，其实应该考虑通过列将它们取出来
#  awk '{print $2,$NF}' log_test.log

# ----------------公司五----------------
"""
    写一个快排的算法程序
"""

# 方式一： 借助lambda实现
the_list = [2, 1, 4, 5, 10, 21, 34, 6]
quick_sort = lambda tempList: tempList if len(tempList) <= 1 else quick_sort([item for item in tempList[1:] if item <= tempList[0]]) + [tempList[0]] + quick_sort([item for item in tempList[1:] if item > tempList[0]])

quick_sorted_list = quick_sort(the_list)
print("列表：{0}快速排序后的新列表为：{1}".format(the_list,quick_sorted_list))

# 方式二：函数式编程+循环
print('-----------------------------')

def quickSort(tempList):
    if len(tempList) <= 1:
        return tempList
    midNum = tempList[len(tempList) // 2]
    tempList.remove(midNum)
    leftList, rightList = [], []
    for i in tempList:
        if i < midNum:
            leftList.append(i)
        else:
            rightList.append(i)
    return quickSort(leftList) + [midNum] + quickSort(rightList)


quick_sorted_list = quickSort(the_list)
print("列表：{0}快速排序后的新列表为：{1}".format(the_list,quick_sorted_list))


# ----------------公司六----------------
"""
    写一个冒泡排序的算法程序
"""
the_list = [123,22,33,23,3,5,778,12]

#冒泡排序(方式一：for循环)
requirement = "冒泡排序"
the_len = len(the_list)
for i in range(0,the_len-1):
    for j in range(0,the_len-1-i):
        if the_list[j] > the_list[j+1]: #从小到大排序用大于号，从大到小排序用小于号
                  the_list[j],the_list[j+1] = the_list[j+1],the_list[j]

print(requirement + "后的列表是："+ str(the_list))
print(requirement + "后的列表是：%s" %(str(the_list)))
print(requirement + "后的列表是：",the_list)

print("while循环实现顺子判断---------------")

"""
冒泡排序(方式二：while循环)
冒泡排序跟九九乘法表很像
"""
the_list = [123,22,33,23,3,5,778,12]
list_002 = [3,2,1,4,5,7,6]

def order_list(a):
    x = 0 
    y = 0 
    while x < len(a):
        while y < (len(a) - x -1):
            if a[y] > a[y+1]:
                           a[y],a[y+1] = a[y+1],a[y]
            y +=1 
        x+=1
        y=0
order_list(the_list)

# ----------------公司七----------------
"""
递归实现统计列表1~9999中3出现的次数
"""

#方式一：循环+递归实现
print('-----------------------------')
a = list(map(lambda x: str(x),list(range(1,10000))))
count = 0 
def theCount(c):
    for i in c:
        if len(i) == 1:
            if i == '3':
                global count
                count +=1 
            else:
                continue
        else:
            theCount(i)
theCount(a)
print("列表[1~9999]中3出现的总次数为:{}".format(count))


#方式二：嵌套循环实现
print('-----------------------------')
count = 0 
for i in a:
    for j in str(i):
        if j == '3':
            count +=1
print("列表[1~9999]中3出现的总次数为:{}".format(count))


"""
  统计列表1~9999中包含3的元素的总个数
"""

#方式一：结合fitler,lambda,re.match()函数实现
print('-----------------------------')
import re 

theList = list(filter(lambda x: re.match('(.*?)3(.*?)',str(x)) ,a))
print("列表[1~9999]中包含3的元素总个数为:{}".format(len(theList)))
print(theList)


#方式二：循环+re模块实现
print('-----------------------------')
count = 0 
for i in a:
    if re.match('(.*?)3(.*?)',i):
        count += 1 
    else:
        continue

print("列表[1~9999]中包含3的元素总个数为:{}".format(count))

#方式三：列表推导式
print('-----------------------------')
theList = [ x for x in a if re.match('(.*?)3(.*?)',x)]
print("列表[1~9999]中包含3的元素总个数为:{}".format(len(theList)))