python面试题学习笔记

2020.5.13

一个只有1和0的list l=[1,1,0,0,1,0,0,1]，在不增加额外内存的情况下，让列表中的0在前面，1在后面

l=[1,1,0,0,1,0,0,1]
for index in range(len(l)):
    if l[index] == 0:
        l.insert(0,l.pop(index))

    

2020.5.14

1. 定义一个同时包含单引号和双引号的str时，用三引号：s = ''' It's "good"'''

   s = ''' It's "good"'''
   print(s)
    
   It's "good"
   
   print(s*3)
   
   It's "good" It's "good" It's "good"

    

2. 用 Python 写一段将字符串转成整数的函数。
   要求：不要调用 int 转换函数。按位读取字符串里的字符进行处理将字符串转化为整数，给
   定的输入一定是合法输入不包含非法字符，字符串头尾没有空格，考虑字符串开头可能有正
   负号
   1. ord(str)返回值是对应的十进制整数，字符串‘0’对应的数字是48，字母‘a’对应的数字是97
      1. ord('3')-48=3
   2. 字符串反转：a[::-1]

      a = "-123456"
      print(a[::-1])
      
      '654321-'

   3. enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中

   4. data = "-123456"
      
      number = sum([(ord(v) - 48) * 10 ** i for i,v in enumerate(data[::-1]) if v != '-' and v != '+'])
      
      number = -number if data[0] == "-" else number
      
      print(number)

       

2020.5.15

1. map函数：map 会根据提供的函数对指定序列做映射。第一个参数是函数，后面的参数是一个可
   迭代对象。以参数序列中的每一个元素调用 function 函数，返回值是新的列表（ python2 ）
   或可迭代对象（ python3 ）。
   1. 语法： map ( function , iterable , ...)
2. filter函数：filter 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列
   表（python2）或迭代器（python3）。该函数接收两个参数，第一个为函数，第二个为可迭代
   对象，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False ，最后将返回 True

   的元素放到新列表（或迭代器）中。

    语法：filter(function, iterable, ...)

3. lambda 函数：“解释一下 lambda 的作用？”
   1. 基础回答：lambda是一个匿名函数

      mysqua = lambda x:x*x
      list1 = [1,2,3,4,5,6]
      list2 = [mysqua(v) for v in list1]
      print(list2)
      
      [1, 4, 9, 16, 25, 36]

      1.  
   2. 加分回答：

      list1 = list(map(lambda x, y: x+y ,[1,2,3,4,5],[1,3,5,7,9]))
      print("map--x+y:")
      print(list1)
      
      list5 = list(map(lambda x:x**2,[1,2,3,4,5]))
      print("map--x**2:")
      print(list5)
      
      list6 = list(map(lambda x:str(x),[1,2,3,4,5]))
      print("map--str:")
      print(list6)
      
      list2 = list(filter(lambda x:x%2==0,[1,2,3,4,5,6,7,8,9,10]))
      print("filter-x%2==0:")
      print(list2)
      
      list3 = list(filter(lambda x:x>0,range(-5,5)))
      print("filter--x>0:")
      print(list3)
      
      运行结果：
      a=[1,2,3,4,5]
      b=[1,3,5,6,7]
      list4 = list(filter(lambda x: x in a, b))
      print("filter--x in a:")
      print(list4)
      
      map--x+y:
      [2, 5, 8, 11, 14]
      map--x**2:
      [1, 4, 9, 16, 25]
      map--str:
      ['1', '2', '3', '4', '5']
      filter-x%2==0:
      [2, 4, 6, 8, 10]
      filter--x>0:
      [1, 2, 3, 4]
      filter--x in a:
      [1, 3, 5]
      

      from functools import reduce
      print(reduce(lambda x,y:x*y,[1,2,3,4]))
      
      24
      

      reduce:从左到右对一个序列的项累计地应用有两个参数的函数，以此合并序列到一个单一值。

      例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])  计算的就是((((1+2)+3)+4)+5)。

4. eval() 函数：用来执行一个字符串表达式，并返回表达式的值。

print(eval('3+4'))

结果：7

2020.5.18 

1. 汉诺塔

2. #汉诺塔a是起始塔，b是辅助塔，c是目标塔，4层的结果，真实测试是对的
   def hannota(n,a,b,c):
       if n == 1:
           print("{}-->{}".format(a,c))
           return None
       if n == 2:
           print("{}-->{}".format(a,b))
           print("{}-->{}".format(a,c))
           print("{}-->{}".format(b,c))
           return None
       else:
           hannota(n-1,a,c,b)
           print("{}-->{}".format(a,c))
           hannota(n-1,b,a,c)
   a = "A"
   b = "B"
   c = "C"
   print(hannota(4,a,b,c))
   
   结果：
   A-->B
   A-->C
   B-->C
   A-->B
   C-->A
   C-->B
   A-->B
   A-->C
   B-->C
   B-->A
   C-->A
   B-->C
   A-->B
   A-->C
   B-->C

    

3.