面试题中python的几种常用功能函数的实现（长期更新）

1、Partition函数与快排和数组中找数
快排与partition

def partition(l,target,start,end):
    if start == end - 1:
        return 0
    length = len(l)
    smaller_end = start - 1
    bigger_start = end
    index = start
    while index < bigger_start:
        if l[index] < target:
            smaller_end += 1
            l[index],l[smaller_end] = l[smaller_end],l[index]
            index += 1
        elif l[index] == target:
            index += 1
        elif l[index] > target:
            bigger_start -= 1
            l[index],l[bigger_start] = l[bigger_start],l[index]
    return l,smaller_end,bigger_start

import random
def quick_sort(l):
    #print(l)
    this_len = len(l)
    if this_len <= 1:
        return l
    random_index = random.randint(0,this_len-1)
    random_target = l[random_index]
    l,se,bs = partition(l,random_target,0,len(l))
    print(l,random_target)
    if se >= 0:
        l[:se+1] = quick_sort(l[:se+1])
    if bs < this_len:
        l[bs:] = quick_sort(l[bs:])
    return l
tosort = [1,-8,64,2,8,6,-745,454,4,7,100,48,466,9]
quick_sort(tosort)

class Solution:
    def findMedianSortedArrays(self, nums1, nums2):
        len1 = len(nums1)
        len2 = len(nums2)
        if len1 == 0:
            if len2 & 1 == 0:#偶数
                return (nums2[len2//2]+nums2[(len2//2)-1])/2
            else:
                return nums2[len2//2]
        if len2 == 0:
            if len1 & 1 == 0:#偶数
                return (nums1[len1//2]+nums1[(len1//2)-1])/2
            else:
                return nums1[len1//2]
        sum_len = len1 + len2
        if nums1[-1] <= nums2[0] or nums2[-1] <= nums1[0]:#list1的最后一个都没有list2的第一个大
            sum_list = nums1 + nums2 if (nums1[-1] <= nums2[0]) else (nums2 + nums1)
            if sum_len & 1 == 1:#odd
                return sum_list[sum_len//2]
            else:
                return (sum_list[sum_len//2] + sum_list[(sum_len//2)-1])/2

        sum_list = nums1 + nums2 
        print(sum_list)
        if sum_len & 1 == 1:#奇数长度，取sum_len//2
            val,_ = self.GetKthxiao(sum_list,sum_len//2)
            return val#self.GetKthxiao(sum_list,sum_len//2)
        elif sum_len & 1 == 0:#偶数长度
            v1,paixu1 = self.GetKthxiao(sum_list,(sum_len//2)-1)
            v2,paixu2 = self.GetKthxiao(paixu1[(sum_len//2):],0)
            return (v1+v2)/2#(self.GetKthxiao(sum_list,sum_len//2) + self.GetKthxiao(sum_list,(sum_len//2)-1))/2
        
        return sum_list[sum_len//2]
    def swap(self,inputlist,s1,s2):
        temp = inputlist[s1]
        inputlist[s1] = inputlist[s2]
        inputlist[s2] = temp
        return inputlist

    def Partition(self,inputlist,start,end,value):
        #这个函数把inputlist里比value大的元素放其右边，把比value小的元素放其左边
        #定义：指针cur:表示当前的游标
        #定义：指针small：表示前small个数确保比value小。初值：start - 1
        #定义：指针big：表示value及其后面的数字确保比value大。初值：end + 1
        #cur从start开始

        small = start - 1
        big = end + 1
        cur = start
        length = len(inputlist)

        while cur != big:
            if inputlist[cur] > value:#当前数字大于mid数字
                big -= 1
                inputlist = self.swap(inputlist,cur,big)
            elif inputlist[cur] < value:#当前数字小于mid数字
                small += 1
                inputlist = self.swap(inputlist,cur,small)
                cur += 1
            else:
                cur += 1
        return inputlist,small+1
    def GetKthxiao(self,inputlist,K):
        length = len(inputlist)
        inputlist,index = self.Partition(inputlist,0,length-1,inputlist[0])
        #代表inputlist[:index]都比inputlist[index]小
        while True:
            print(inputlist)
            if index < K:
                inputlist,index = self.Partition(inputlist,index+1,length-1,inputlist[index+1])
            elif index > K:
                inputlist,index = self.Partition(inputlist,0,index-1,inputlist[index-1])
            elif index == K:
                #代表inputlist[:K]都比inputlist[K]小
                #inputlist[K]是inputlist第K小的数字
                return inputlist[K],inputlist

2、生成一个数组中所有元素的全排列

简单实现：
2.1、如果没有重复元素

def qpl(a,res):
    if len(a) == 1:
        res.append(a[0])
        print(res)#res
    else:
        for i,value in enumerate(a):
            qpl(a[:i]+a[i+1:],res+[value])
qpl([1,2,3,4],[])

2.2、如果有重复元素

def qpl_youchongfu(x):#a中有元素重复
    rem = set()
    def qpl_child(a,res):
        if len(x) == len(res):
            if str(res) not in rem:
                rem.add(str(res))
                print(res)
        else:
            for i,value in enumerate(a):
                qpl_child(a[:i]+a[i+1:],res+[value])
    qpl_child(x,[])
    

3、判断一个字符（串）是不是字母或数字

https://blog.csdn.net/weixin_41775301/article/details/87900982

s.isalnum() 所有字符都是数字或者字母，为真返回 Ture，否则返回 False。（重点，这是字母数字一起判断的！！）

s.isalpha() 所有字符都是字母，为真返回 Ture，否则返回 False。（只判断字母）

s.isdigit() 所有字符都是数字，为真返回 Ture，否则返回 False。（只判断数字）

s.islower() 所有字符都是小写，为真返回 Ture，否则返回 False。

s.isupper() 所有字符都是大写，为真返回 Ture，否则返回 False。

s.istitle() 所有单词都是首字母大写，为真返回 Ture，否则返回 False。

s.isspace() 所有字符都是空白字符，为真返回 Ture，否则返回 False。

或正则：

p=''.join(re.findall(r'[a-zA-Z0-9]+',s))
p=p.lower()

4、位与运算的妙用

5、字符串与ascii

https://www.runoob.com/python3/python3-ascii-character.html

6、Python中的二进制与位运算
进制转换

https://blog.csdn.net/py_tester/article/details/78221425

转化为10进制：

input_str = '转换之前的结果，保存为字符串形式'
before = 上述数字是多少进制的#int
int(input_str,after)#将上述数字转化为10进制

10进制转化为2、8、16进制

x = 12345
Ten_Two = bin(x) 
Ten_Eight = oct(x) 
Ten_Sixteen = hex(x) 

注意：bin(number)–>’0b…’
oct(number)–>’0o…’
hex(number)–>’0x…’
要获取纯数字结果的话需要加[2:]

eval函数可以判断不同进制的表达的值是否相等

eval('0x11')==17#返回True

位运算：
小技巧：判断奇数偶数

#n为奇数
n & 1 == 1#True
#m为偶数
m & 1 == 0#False 

https://blog.csdn.net/GrofChen/article/details/91374573