常见例题

Posted 2021-01-13 542684416-qq

‘‘‘
第一题：去除列表中的重复元素
1.列表中的元素有重复，需要去掉重复元素
2.要求保留原来的元素顺序
3.不需要返回值，直接修改原列表即可
‘‘‘

lt = [3,2,1,8,4,3,4,5,5,6,6,7]
def duplicate_removal(lt):
lt1 = []
for i in lt:
if i not in lt1:
lt1.append(i)
return lt1
print(duplicate_removal(lt))

‘‘‘
第二题：计算字符串中所有数字的和
1.字符串中只有小写字母和数字
2.数字可能连续，也可能不连续
3.连续数字要当做一个数处理
如：‘12abc34de5f‘ => 12 + 34 + 5 => 51
‘‘‘

s = ‘12abc34de5f‘
def sum_of_num(s):
ret = 0
num = 0
for i in s:
if i.isdecimal():
a = int(i)
ret = ret * 10 + a
else:
num += ret
ret = 0
num += ret
return num
print(sum_of_num(s))

‘‘‘
第三题：返回列表中的第二小的元素的下标
1.参数是一个列表，元素全部是整数
2.返回第二小的元素的下标
‘‘‘

lt = [5,6,7,3,1,4,9]
def seconde_min(lt):
a =sorted(lt)
b = a[1]
c = lt.index(b)
return c
print(seconde_min(lt))

 

‘‘‘
第四题：写出冒泡排序函数，可以排序任意类型的元素，可以逆序
1.实现冒泡排序算法
2.可以排序任意类型的元素
3.能够通过参数设置进行逆序，默认升序
‘‘‘

def list_sort(lt, key=None, reverse=False):
for i in range(len(lt)-1):
for j in range(len(lt)-i-1):
if key:
if reverse:
if key(lt[j]) < key(lt[j+1]):
lt[j] , lt[j+1] = lt[j+1] , lt[j]
else:
if key(lt[j]) > key(lt[j + 1]):
lt[j], lt[j + 1] = lt[j + 1], lt[j]
else:
if reverse:
if lt[j] < lt[j + 1]:
lt[j], lt[j + 1] = lt[j + 1], lt[j]
else:
if lt[j] > lt[j + 1]:
lt[j], lt[j + 1] = lt[j + 1], lt[j]
return lt
lt = [
{‘name‘: ‘xiaoming‘, ‘age‘: 18},
{‘name‘: ‘xiaoming‘, ‘age‘: 15},
{‘name‘: ‘xiaoming‘, ‘age‘: 16},
{‘name‘: ‘xiaoming‘, ‘age‘: 17}
]
print(list_sort(lt, key=lambda d: d[‘age‘], reverse=False))

‘‘‘

第五题：自己实现一个字符串的find函数
1.在一个字符串中查找另一个字符串
2.找到了返回第一次出现的位置
3.没找到返回-1
4.参数s1为源字符串，参数s2为要查找的字符串
‘‘‘

s1 = ‘asdf5g4f5d2cx54‘
s2 = str(input(‘请输入一个字符串：‘))

def index_of_str(s1, s2):
if s2 in s1:
return s1.index(s2[0])
else:
return -1
print(index_of_str(s1,s2))

导入需要的包

from functools import  reduce
from  collections import  Counter
import re
from  datetime import datetime
import time

‘‘‘(10分)
简述下列关键字或变量的作用
1.global和nonlocal的作用
2.pass、return、break、continue的作用
3.*args、**kwargs的作用
‘‘‘

def short_answer():
    return ‘‘‘
        global:全局变量，使用当前作用域作用于全局
        nonlocal:局部变量，声明使用的不是本地变量，是外部函数的局部变量
        pass:占位符号，保证程序运行顺畅，不会报错
        return:当函数在执行的时候遇到return时，立即停止运行，并返回结果
        break:当函数运行到break时，函数立即结束，不再往下继续进行
        continue:函数执行到continue时，会结束本次循环，继续进行下次循环
        *args:是一个元组，存放多余的位置参数
        **kwargs:是一个字典，存放多余的关键字参数
    ‘‘‘

‘‘‘(15分)
1.求列表中所有数字元素的和
2.列表中的元素都是整数
3.列表中的元素可能重复，需要去掉重复元素
4.需要使用高级函数实现求和
5.返回计算的结果
‘‘‘

def sum_of_list(lt):
    lt1 = []
    for i in lt:
        if i not in lt1:
            lt1.append(i)
    num = reduce(lambda x,y:x+y,lt1)
    return num
# lt = [1,2,3,8,6,4,8,7,2,4,5,4,6]
# print(sum_of_list(lt))

‘‘‘(15分)
1.传入一个列表，列表中元素可能是任意类型
2.使用高级函数完成非字符串元素的删除
3.然后按照字符串的长度进行降序排序
4.返回新的排序后的列表
‘‘‘

def sort_list(lt):
    lt1 = list(filter(lambda x :isinstance(x,str),lt))
    lt2 = sorted(lt1,key=lambda x:len(x),reverse=True)
    return lt2
# lt = [12,‘sdfw‘,58,‘qwy‘,{‘name‘:6,‘age‘:20},‘rejdj‘]
# print(sort_list(lt))

‘‘‘(15分)
1.返回一个字符串中出现次数第二多的单词
2.字符串中可能有英文单词、标点、空格
3.字符串中的英文字符全部是小写
‘‘‘

def max_count_word(s):
    a = re.compile(r‘W‘)
    b = a.sub(‘ ‘,s)
    c = b.split()
    print(c,type(c))
    d = dict(Counter(c))
    e = d.items()
    lt = sorted(e,key=lambda x :x[1],reverse=True)
    print(lt)
    return lt[1][0]
s = ‘      if   you        tell me     love  his,        we want   to say : i love      you too!‘
print(max_count_word(s))
?

‘‘‘(15分)
1.传入年、月、日，返回该日是当年的第几天
2.返回值是一个整数
‘‘‘

def which_day(y, m, d):
    t1 = datetime(y,m,d)
    t2 = datetime(y,1,1)
    t = t1-t2
    return t.days+1
# print(which_day(2018,1,2))

‘‘‘(15分)
1.写一个装饰器，查看函数执行的时间
2.在装饰器中打印执行时间即可
3.递归函数除外
‘‘‘

def continue_time(func):
    def warrper(*args,**kwargs):
        start = time.time()
        func(*args，**kwargs)
        end = time.time()
        return ‘函数执行的时间：{}‘.format(end - start)
    return warrper
@continue_time
def test():
    a = 1
    i = 1
    while i<=1000:
        a = a*i
        i +=1
    print(a)
# print(test())

 

‘‘‘(15分)
1.返回列表中最后剩下的元素
2.传入列表，和步进值(隔几个删除数据)
3.从第一个元素起，查到步进值就删掉该元素
4.到结尾后，返回第一个元素继续累计查询
‘‘‘

from collections import deque
import collections
def last_item(lt, step):
    while True:
        lt = collections.deque(lt)
        lt.rotate(step*-1)
        lt.pop()
        if len(lt)==1:
            return lt.pop()
lt = [1,2,3,4,5,6,7]
# print(last_item(lt,2))