python 笔试总结

1、对比两种函数对应结果

def fn(x):
    if x>0:
        print(x)
        fn(x-1)
****结果******
3
2
1
$$$$$$另外一种$$$$$$$$$
def fn(x):
    if x>0:
        fn(x-1)
         print(x)
****结果******
1
2
3

2.简单的方式写下斐波那契数列

1、递推法

def fn(n):
    a,b=0,1
    for i in range(n+1)
        a,b=b,a+b
    return a
print(fn(5))
******结果********
8

2、递归法

def fn(n):
    if n==1 or n==0:
        return 1
    return fn(n-1)+fn(n-2)
print(fn(5))
*****结果******
8

3、给出一个整数求各个位的数值

def get_diget(num,i):
    return num//(10**i)%10 #各位数i取0
print(get_diget(1314,2))

4、将一个整数变成一个列表

　　

def int2list(num):
    li=[]
    while num>0:
        li.append(num %10) #每次取余数得出最后一位的值加入列表
        num= num //10#运算一位后整除10，剩下的num少一位进入下次循环
    li.reverse()
    return li
print(int2list(13156))
******结果******
[1,3,1,5,6]

5、对整数进行翻转操作（123=>321）

def reverse_int(num):
    res=0
    while num>0:
        res=res*10    #从十位开始每次*10位数增加一位
        res+=num % 10 #num %10 得出最后一个的值 加到res
        num=num//10  #循环一次num的值少一位
    return res
print(reverse_int(123))
****结果******
321
如果输入结果123000 翻转后结果也是321

6、用装饰器写一个计时函数：

　装饰器的作用：1、引入日志  2、函数执行时的时间统计 3、执行函数前预备处理  4、执行函数后的清理处理 5、权限校验等场景  6、缓存

def metric(fn):
　　#空白处                    #当装饰器内部调用了__name__等类的方法时候需要在空白处填写@functools.wraps(fn)，如果没有调用类的内置方法无需填写
    def wrapper(*args,**kwargs):
        start=time.time()
        func=fn(*args,**kwargs)
        end=time.time()
        print('运行时间%s'%(end-start))  #print('%s 运行时间 %s s' % (fn.__name__, end-start )) 
        return func
    return wrapper
@metric
def reverse_int(num):
    res=0
    while num>0:
        res=res*10    #从十位开始每次*10位数增加一位
        res+=num % 10 #num %10 得出最后一个的值 加到res
        num=num//10  #循环一次num的值少一位
    return res
print(reverse_int(123))

7 、two sum问题：给定一个整数数组和一个目标值，找出数组中和为目标值的两个数要求返回这两个数所在的位置

第一种两边找方法：时间复杂度o(n) 该方法要求给定的列表要是有序的列表。
def two_sum(li,num):
    i=0 #i是轮询查找起始位置
    j=len(li)-1 #j为轮询查找最后一个位置
    dict={}
    for k,v in enumerate(li): #将列表转换为字段，列表的值作为key,列表元素下标做字典的value
        dict[v]=k
    li_sort=sorted(dict.keys()) #对生成的字典按key进行排序得到排序后的列表
    while i<j : #只要i<j 说明轮询查找未结束
        s=li_sort[i]+li_sort[j] #列表中两个元素相加的结果
        if s==num :
            return dict[li_sort[i]],dict[li_sort[j]] #根据得到的值查询得到结果在原始列表的下标
        elif s<num :
            i+=1   #当两个元素相加值小于要查找的结果时说明前面的数值太小 i的位置向后移动一个位置
        elif s>num:
            j-=1   #当两个元素相加值大于要查找的结果时说明后面的数值太大 j的位置向前移动一个位置
    else:
        return -1
b=[8,3,6,9,7,2]
c=two_sum(b,14)
print(c)
****结果*****
(2, 0)

　　第二种：利用哈希表的方式：时间复杂度0（n）

def two_sum2(li,num):
    dict={}
    for i in range(len(li)):
        a=li[i]
        b=num-a
        if b not in dict: #检查b是否在字典中，若果没有将值写入字典，直到找到要得到的值
            dict[a]=i
        else:
            return dict[b],i
    else:
        return -1
b=[8,3,6,9,7,2]
c=two_sum2(b,14)
print(c)
*****结果*****
（0,2）

8、1 and 2 or 3 and 4的结果

在python里面，0,'',[],{},() 和None为假，其它任何东西都为真。
一、and的使用
    1 and 2 和 [] and 1
   如果没有假值，返回的是最后一个真值，如果有假值，则返回的是第一个假值。
***结果****
2
[]
二、or 的使用
2 or 3 和 [] or 2
如果没有真值，返回的是最后一个假值，如果有真值，则返回的是真值。
***结果****
2
2
三、在不加括号的前提下 and 的优先级大于or
所以 1 and 2 or 3 and 4  运算结果为:
 1 and 2 为2 >- 3 and 4 为4 >- 2 or 4 为2

9、利用堆栈的方法做一个括号匹配函数:

def brace_match(n):
    stack=[]
    dict={'(':')','[':']','{':'}'}
    for ch in n:
        if ch in ('(','{','[') :
            stack.append(ch)
        elif len(stack) == 0: #注意判断stack的长度要先与出栈右括号
            print('多出一个右括号%s' % ch)
            return False
        elif dict[stack[-1]]==ch:
            stack.pop()
        else:
            print('括号%s处不匹配'%ch)
    if len(stack)==0:
        return True
    else:
        print('剩余左括号未匹配')
        return False

10.利用队列读取一个文件的最后n行数据

from collections import deque
q=deque(open('test.txt','r',encoding='utf-8'),5)
原理：设定了固定长度的队列，当读取的时候直接进队出队，直到最后N个数据
例如：

q=deque([1,2,3,4,5,6],5)

print(list(q))
***结果****
[2,3,4,5,6] #1由于队列长度限制已经出队，剩余2,3,4,5,6

11、利用python内置方法求差级、交集、并集

a=[1,2,3]
b=[3,4,5]
c=list(set(a)|set(b) #求并集
c=list(set(a)&set(b))#求交集
c=list(set(a)-set(b))#求差级（求差级两个变量位置不同得出的结果不同）
c=list(set(a)^set(b))对称差集（项在a或b中，但不会同时出现在二者中)
*****结果******
[1,2,3,4,5]
[3]
[1,2]
[1,2,4,5]
差集举例
c=list(set(b)-set(a))
结果为[4,5]

12、给定两个有序数组，对这两个数组进行排序

def merge2list(arr1,arr2):
    arr=[]
    i=0
    j=0
    while i< len(arr1) and j< len(arr2):
        if arr1[i] <= arr2[j]:
            arr.append(arr1[i])
            i+=1
        else:
            arr.append(arr2[j])
            j+=1
    while i< len(arr1):
        arr.append(arr1[i])
        i+=1
    while j< len(arr2):
        arr.append(arr2[j])
        j+=1
    return arr
arr1=[1,3,5,7]
arr2=[2,4,6,8,10]
print(merge2list(arr1,arr2))

13，二分发查找，要求数据为有序数列

def bin_search(data_set,val):
    #low 和high代表下标 最小下标，最大下标
    low=0
    high=len(data_set)-1
    while low <=high:# 只有当low小于High的时候证明中间有数
        mid=(low+high)//2
        if data_set[mid]==val:
            return mid  #返回他的下标
        elif data_set[mid]>val:
            high=mid-1
        else:
            low=mid+1
    return # return null证明没有找到
data_set = list(range(100000000))