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))

巴特西

python 笔试总结

最新文章

热门文章