面试：python面试中手写代码的环节

浅浅的花香味﹌ 2023-02-21 15:25 9阅读 0赞

#### 1.如何反向迭代一个序列 ####

#如果是一个list,最快的方法使用reverse
    tempList = [1,2,3,4]
    tempList.reverse()
    for x in tempList:
        print x
     
    
    #如果不是list,需要手动重排
    templist = (1,2,3,4)
    for i in range(len(templist)-1,-1,-1):
        print templist[i]

#### 2.如何查询和替换一个文本中的字符串 ####

#最简单的方法使用replace()
    tempstr = "hello you hello python are you ok"
    print tempstr.replace("you","python")
     
    
    #还可以使用正则,有个sub()
    tempstr = "hello you hello python are you ok"
    import re
    rex = r'(hello|Use)'
    print re.sub(rex,"Bye",tempstr)

#### 3.使用python实现单例模式 ####

#方法一:可以使用__new__方法
    #在__new__方法中把类实例绑定到类变量_instance上，如果cls._instance为None表示该类还没有实例化过，实例化该类并返回。如果cls_instance不为None表示该类已实例化，直接返回cls_instance
    class SingleTon(object):
        def __new__(cls,*args,**kwargs):
            if not hasattr(cls,'_instance'):
                cls._instance = object.__new__(cls,*args,**kwargs)
            return cls._instance
    class TestClass(SingleTon):		#直接继承
        a = 1
    
    
    #方法二:使用装饰器,建立过实例的就放到instances里面,下次建立的时候先检查里面有没有
    def SingleTon(cls,*args,**kwargs):
        instances = {
        }
        print instances
        def _singleton():
            if cls not in instances:
                instances[cls] = cls(*args,**kwargs)
            print instances
            return instances[cls]
        return _singleton
    
    @SingleTon
    class LastClass(object):
        a = 1

#### 4.闭包 ####

常用的装饰器就是闭包的一种

def make_adder(addend): 
        def adder(addend): 
            return addend+addend 
    return adder
    
    P1 = make_adder(5) 
    P2= make_adder(4)
    
    print p1(10) 
    #输出15 
    print p2(10) 
    #输出14

#### 5.给列表中的字典排序 ####

alist = [{
        “name”:”a”,”age”:20},{
        “name”:”b”,”age”:30},{
        “name”:”c”,”age”:25}]
    按照 age 从大到小排序
    
    alist = [{
        "name":"a","age":20},{
        "name":"b","age":30},{
        "name":"c","age":25}]
    alist.sort(key=lambda:x:-x.get("age"))
    print alist

#### 6.简单的实现一个栈结构 stack ####

class Stack(object):
        def __init__(self):
            self.value = []
    
        def push(self,x):
            self.value.append(x)
    
        def pop(self):
            self.value.pop()
    
    stack = Stack()
    
    stack.push(1)
    stack.push(2)
    stack.push(3)
    print(stack.value)
    stack.pop()
    print(stack.value)

#### 7.输入一个日期,返回时一年中的哪一天 ####

from datetime import datetime
    def which_day(year,month,day):
        return (datetime(year,month,day)-datetime(year,1,1)).days+1
    
    print(which_day(2017,1,15))

#### 8.判断输入的值是否在矩阵之中(杨氏矩阵) ####

在一个二维数组之中,每一行都按照从走到右递增的顺序排序,每一列到按照从上到下的顺序排序.请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数

#处理数组矩阵
    arr = [[1,4,7,10,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]]
    def get_num(num,data=None):
        while data:
            if num > data[0][-1]:
                del data[0]
            elif num<data[0][-1]:
                data = list(zip(*data))
                del data[-1]
                data = list(zip(*data))
            else:
                return True
                data.clear()
        return False
    print (get_num(18,arr))

#### 9.获取最大公约数(欧几里得算法) ####

a = 25
    b = 15
    
    def max_common(a,b):
        while b:
            a,b=b,a%b
        return a

#### 10.求两个数的最小公倍数(公式法) ####

两个数的乘积等于这两个数的 最大公约数与最小公倍数的积

a = 25
    b = 15
    def min_common(a,b):
        c= a*b
        while b:
            a,b=b,a%b
        return c//a

#### 11.选择排序算法 ####

def select_sort(origin_items):
    	""" 选择排序算法 """
      items = origin_items[:]
      for i in range(len(items) -1):
        min_index = i
        for j in range(i + 1, len(items)):
          if items[j] < items[min_index]:
            min_index = j
        items[i], items[min_index] = items[min_index], items[i]
    
      return items

#### 12.归并法/分治法排序 ####

def merge_sort(arr):
    """ 归并法/分治法排序 """
      if len(arr) < 2:
        return arr[:]
      mid = len(arr) // 2
      left = merge_sort(arr[:mid])
      right = merge_sort(arr[mid:])
      return merge(left, right)
    
    def merge(left, right):
      print(left)
      print(right)
      print('\n')
      result = []
      index_left, index_right = 0, 0
    
      while index_left < len(left) and index_right < len(right):
        if left[index_left] <= right[index_right]:
          result.append(left[index_left])
          index_left += 1
        else:
          result.append(right[index_right])
          index_right += 1
      result += left[index_left:]
      result += right[index_right:]
      return result

#### 13.冒泡排序 ####

def bubble_sort(origin_items):
      """ 冒泡排序算法 """
      items = origin_items[:]
      for i in range(len(items) - 1):
        for j in range(0, len(items) - 1 -i):
          if items[j] > items[j + 1]:
            items[j], items[j + 1] = items[j + 1], items[j]
      return items

#### 14.递归实现快排 ####

class Solution():
        def quicksort(self, list, low, high):
            if low >= high:
                return list
            left = low
            right = high
            num = list[low]
            while left < right:
                while list[right] >= num and left < right:
                    right = right - 1
                list[left] = list[right]
                while list[left] <= num and left < right:
                    left = left + 1
                list[right] = list[left]
            list[left] = num
            return self.quicksort(list, low, left-1)
            return self.quicksort(list, left+1, high)

#### 15.二分查找（非递归） ####

def merge_search(self, li, item):
            start = 0
            end = len(li) - 1
            while start <= end:
                mid = (start + end) // 2
                if li[mid] == item:
                    return '要查找的元素为：{}，位置是：{}'.format(item, li.index(li[mid]))
                elif li[mid] > item:
                    end = mid - 1
                else:
                    start = mid + 1

#### 16.二分查找（递归） ####

def bin_serach(list, value, low , high):
        #递归出口
        if low > high:   
            return -1
        mid = low + ((high - low)>>1) #避免大数溢出
        if list[mid] > value:
            return bin_serach(list, value, low , mid-1)
        elif list[mid] < value:
            return bin_serach(list, value, mid+1, high)
        else:
            return mid

#### 17.插入查找 ####

def interpolation_search(nums, key):
        low = 0
        high = len(nums) -1
        
        while(nums[low]<= key <=nums[high] and nums[low] !=nums[high]):
            mid = low + int((key - nums[low])*(high - low)/(nums[high]-nums[low]))
            if nums[mid] < key:
                low = mid + 1
            elif nums[mid] > key:
                high = mid - 1
            else:
                return mid
            
        if key == nums[low]:
            return low
        else:
            return -1