1.B Tree和B+ Tree的区别?

  1. 1.B树中同一键值不会出现多次,并且有可能出现在叶结点,也有可能出现在非叶结点中。
  2. B+树的键一定会出现在叶结点中,并有可能在非叶结点中重复出现,以维持B+树的平衡。
  3. 2.因为B树键位置不定,且在整个树结构中只出现一次,

2.请列举常见排序并通过代码实现任意三种。

3.请列举常见查找并通过代码实现任意三种。

4.台阶问题/斐波那契 

一只青蛙一次可以跳上1级台阶,也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

  1. def memo(func):
  2. cache = {}
  3. def wrap(*args):
  4. if args not in cache:
  5. cache[args] = func(*args)
  6. return cache[args]
  7. return wrap
  8.  
  9. @memo
  10. def fib(i):
  11. if i < 2:
  12. return 1
  13. return fib(i-1) + fib(i-2)

5.变态台阶问题

一只青蛙一次可以跳上1级台阶,也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

  1. fib = lambda n: n if n < 2 else 2 * fib(n - 1)

6.矩形覆盖

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形,总共有多少种方法?

2*n个矩形的覆盖方法等于第2*(n-1)加上第2*(n-2)的方法。

  1. f = lambda n: 1 if n < 2 else f(n - 1) + f(n - 2)

7.杨氏矩阵查找

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

  1. def get_value(l, r, c):
  2. return l[r][c]
  3.  
  4. def find(l, x):
  5. m = len(l) - 1
  6. n = len(l[0]) - 1
  7. r = 0
  8. c = n
  9. while c >= 0 and r <= m:
  10. value = get_value(l, r, c)
  11. if value == x:
  12. return True
  13. elif value > x:
  14. c = c - 1
  15. elif value < x:
  16. r = r + 1
  17. return False

8.去除列表中的重复元素

  1. list(set(l))
  1. l1 = ['b','c','d','b','c','a','a']
  2. l2 = []
  3. [l2.append(i) for i in l1 if not i in l2]

9.链表成对调换

1->2->3->4转换成2->1->4->3.

  1. class ListNode:
  2. def __init__(self, x):
  3. self.val = x
  4. self.next = None
  5.  
  6. class Solution:
  7. # @param a ListNode
  8. # @return a ListNode
  9. def swapPairs(self, head):
  10. if head != None and head.next != None:
  11. next = head.next
  12. head.next = self.swapPairs(next.next)
  13. next.next = head
  14. return next
  15. return head

10.创建字典的方法

  1. items=[('name','earth'),('port','')]
  2. dict2=dict(items)
  3. dict1=dict((['name','earth'],['port','']))

11.合并两个有序列表

循环算法

思路:

定义一个新的空列表

比较两个列表的首个元素

小的就插入到新列表里

把已经插入新列表的元素从旧列表删除

直到两个旧列表有一个为空

再把旧列表加到新列表后面

  1. def loop_merge_sort(l1, l2):
  2. tmp = []
  3. while len(l1) > 0 and len(l2) > 0:
  4. if l1[0] < l2[0]:
  5. tmp.append(l1[0])
  6. del l1[0]
  7. else:
  8. tmp.append(l2[0])
  9. del l2[0]
  10. tmp.extend(l1)
  11. tmp.extend(l2)
  12. return tmp

pop弹出

  1. a = [1,2,3,7]
  2. b = [3,4,5]
  3.  
  4. def merge_sortedlist(a,b):
  5. c = []
  6. while a and b:
  7. if a[0] >= b[0]:
  8. c.append(b.pop(0))
  9. else:
  10. c.append(a.pop(0))
  11. while a:
  12. c.append(a.pop(0))
  13. while b:
  14. c.append(b.pop(0))
  15. return c
  16. print merge_sortedlist(a,b)
  1. #第三种方法
    def merge(a, b):
  2. c = []
  3. h = j = 0
  4. while j < len(a) and h < len(b):
  5. if a[j] < b[h]:
  6. c.append(a[j])
  7. j += 1
  8. else:
  9. c.append(b[h])
  10. h += 1
  11.  
  12. if j == len(a):
  13. for i in b[h:]:
  14. c.append(i)
  15. else:
  16. for i in a[j:]:
  17. c.append(i)
  18.  
  19. return c

12.交叉链表求交点

其实思想可以按照从尾开始比较两个链表,如果相交,则从尾开始必然一致,只要从尾开始比较,直至不一致的地方即为交叉点,如图所示

另外一种比较正规的方法,构造链表类

  1.  
  1. class Node(object):
  2. def __init__(self, value=None, next=None):
  3. self.value = value
  4. self.next = next
  5.  
  6. def get_list_length(head):
  7. """获取链表长度"""
  8. length = 0
  9. while head:
  10. length += 1
  11. head = head.next
  12. return length
  13.  
  14. def get_intersect_node(list_a, list_b):
  15. """查找链表第一个交叉结点"""
  16. length_a = get_list_length(list_a)
  17. length_b = get_list_length(list_b)
  18.  
  19. cur1, cur2 = list_a, list_b
  20. if length_a > length_b:
  21. for i in range(length_a - length_b):
  22. cur1 = cur1.next
  23. else:
  24. for i in range(length_b - length_a):
  25. cur2 = cur2.next
  26.  
  27. flag = False
  28. while cur1 and cur2:
  29. if cur1.value == cur2.value:
  30. print(cur1.value)
  31. flag = True
  32. break
  33. else:
  34. cur1 = cur1.next
  35. cur2 = cur2.next
  36.  
  37. if not flag:
  38. print('链表没有交叉结点')
  39.  
  40. if __name__ == '__main__':
  41. list_a = Node('a1', Node('a2', Node('c1', Node('c2', Node('c3'))))) # 构造不带头结点的链表:a1→a2→c1→c2→c3
  42. list_b = Node('b1', Node('b2', Node('b3', Node('c1', Node('c2', Node('c3')))))) # 构造不带头结点的链表:b1→b2→b3→c1→c2→c3
  43.  
  44. get_intersect_node(list_a, list_b)

13.二分查找

  1. #coding:utf-8
  2. def binary_search(list, item):
  3. low = 0
  4. high = len(list) - 1
  5. while low <= high:
  6. mid = (high - low) / 2 + low # 避免(high + low) / 2溢出
  7. guess = list[mid]
  8. if guess > item:
  9. high = mid - 1
  10. elif guess < item:
  11. low = mid + 1
  12. else:
  13. return mid
  14. return None
  15. mylist = [1,3,5,7,9]
  16. print binary_search(mylist, 3)

14.快排

  1. #coding:utf-8
  2. def quicksort(list):
  3. if len(list)<2:
  4. return list
  5. else:
  6. midpivot = list[0]
  7. lessbeforemidpivot = [i for i in list[1:] if i<=midpivot]
  8. biggerafterpivot = [i for i in list[1:] if i > midpivot]
  9. finallylist = quicksort(lessbeforemidpivot)+[midpivot]+quicksort(biggerafterpivot)
  10. return finallylist
  11.  
  12. print(quicksort([2,4,6,7,1,2,5]))

15.找零问题

  1. #coding:utf-8
  2. #values是硬币的面值values = [ 25, 21, 10, 5, 1]
  3. #valuesCounts 钱币对应的种类数
  4. #money 找出来的总钱数
  5. #coinsUsed 对应于目前钱币总数i所使用的硬币数目
  6.  
  7. def coinChange(values,valuesCounts,money,coinsUsed):
  8. #遍历出从1到money所有的钱数可能
  9. for cents in range(1,money+1):
  10. minCoins = cents
  11. #把所有的硬币面值遍历出来和钱数做对比
  12. for kind in range(0,valuesCounts):
  13. if (values[kind] <= cents):
  14. temp = coinsUsed[cents - values[kind]] +1
  15. if (temp < minCoins):
  16. minCoins = temp
  17. coinsUsed[cents] = minCoins
  18. print ('面值:{0}的最少硬币使用数为:{1}'.format(cents, coinsUsed[cents]))

16.广度遍历和深度遍历二叉树

17.二叉树节点

  1. class Node(object):
  2. def __init__(self, data, left=None, right=None):
  3. self.data = data
  4. self.left = left
  5. self.right = right
  6.  
  7. tree = Node(1, Node(3, Node(7, Node(0)), Node(6)), Node(2, Node(5), Node(4)))

18.图的广度优先遍历

  1. import Queue
  2.  
  3. def bfs(adj, start):
  4. visited = set()
  5. q = Queue.Queue()
  6. q.put(start)
  7. while not q.empty():
  8. u = q.get()
  9. print(u)
  10. for v in adj.get(u, []):
  11. if v not in visited:
  12.   visited.add(v)
  13.   q.put(v)
  14.  
  15. graph = {1: [4, 2], 2: [3, 4], 3: [4], 4: [5]}
  16. bfs(graph, 1)

19.图的深度优先遍历

def dfs(adj, start):
visited = set()
stack = [[start, 0]]
while stack:
(v, next_child_idx) = stack[-1]
if (v not in adj) or (next_child_idx >= len(adj[v])):
stack.pop()
continue
next_child = adj[v][next_child_idx]
stack[-1][1] += 1
if next_child in visited:
continue
print(next_child)
visited.add(next_child)
stack.append([next_child, 0])

graph = {1: [4, 2], 2: [3, 4], 3: [4], 4: [5]}
dfs(graph, 1)
————————————————

上面的代码是dfs的非递归实现,其实递归的代码更简单,但是我觉得使用了函数的递归调用隐含了对栈的使用但是却没有明确出来,这样不太利于对dfs核心思想的理解,所以这里反而选择了更复杂的非递归实现。

整个程序借助了一个栈,由于python没有直接的实现栈,这里使用了list来模拟,入栈就是向列表中append一个元素,出栈就是取列表最后一个元素然后pop将最后一个元素删除

下面来分析实现过程,还是按之前的那句话“顺着起点往下走,直到无路可走就退回去找下一条路径,直到走完所有的结点”,整个程序都蕴含在这句话中:

首次是“顺着起点往下走”中的起点当然就是函数传进来的参数start,第三行中我们把起点放到了栈中,此时栈就是初始状态,其中就只有一个元素即起点。那么栈中元素表示的语义是:下一次将访问的结点,没错就这么简单,那么为什么我们一个结点和一个索引来表示呢?理由是这样的,由于我们使用邻接表来表示图,那么要表示一个结点表可以用<这个结点的父结点、这个结是父结点的第几个子结点>来决定,至于为什么要这么表示,就还是前面说的:由这们这里使用的图的存储方式-邻接表决定了,因为这样我们取第N个兄弟结点要容易了。因为邻接表中用list来表示一个结点的所有子结点,我们就用一个整数的索引值来保存下次要访问的子结点的list的下标,当这个下标超过子结点list的长度时意味着访问完所有子结点。

接着,“往下走”,看这句:next_child = adj[v][next_child_idx]就是我们在这个while循环中每次访问的都是一个子结点,访问完当前结点后stack.append([next_child, 0])将这个结点放到栈中,意思是下次就访问这个结点的子结点,这样就每次都是往下了。

“直到无路可走”,在程序中的体现就是 if (v not in adj) or (next_child_idx >= len(adj[v])):,栈顶元素表示即将要访问的结点的父结点及其是父结点的第N个子结点(有点绕),这里的意思是如果这个父结点都没有子结点了或者是我们想要访问第N个子结点但是父结点并没有这么多子结点,表示已经访问完了一个父结点的所有子结点了。

接着“就退回去找下一条路径”中的“退回去”,怎么退回去,很简单将栈顶元素弹出,新的栈顶元素就是它的父结点,那么就是退回去了,“去找下一条路径”就是弹出栈顶后下一次while中会沿着父结点继续探索,也就是去找下一条路径了。

最后“直到走完所有的结点“当然就是栈为空了,栈为空表示已经回退到起点,即所有结点已经访问完了,整个算法结束。

20.前中后序遍历

  1. #coding:utf-8
  2. #二叉树的遍历
  3. #简单的二叉树节点类
  4. class Node(object):
  5. def __init__(self,value,left,right):
  6. self.value = value
  7. self.left = left
  8. self.right = right
  9.  
  10. #中序遍历:遍历左子树,访问当前节点,遍历右子树
  11.  
  12. def mid_travelsal(root):
  13. if root.left is not None:
  14. mid_travelsal(root.left)
  15. #访问当前节点
  16. print(root.value)
  17. if root.right is not None:
  18. mid_travelsal(root.right)
  19.  
  20. #前序遍历:访问当前节点,遍历左子树,遍历右子树
  21.  
  22. def pre_travelsal(root):
  23. print (root.value)
  24. if root.left is not None:
  25. pre_travelsal(root.left)
  26. if root.right is not None:
  27. pre_travelsal(root.right)
  28.  
  29. #后续遍历:遍历左子树,遍历右子树,访问当前节点
  30.  
  31. def post_trvelsal(root):
  32. if root.left is not None:
  33. post_trvelsal(root.left)
  34. if root.right is not None:
  35. post_trvelsal(root.right)
  36. print (root.value)

21.求最大树深

  1. def maxDepth(root):
  2. if not root:
  3. return 0
  4. return max(maxDepth(root.left), maxDepth(root.right)) + 1

22.求两棵树是否相同

  1. def isSameTree(p, q):
  2. if p == None and q == None:
  3. return True
  4. elif p and q :
  5. return p.val == q.val and isSameTree(p.left,q.left) and isSameTree(p.right,q.right)
  6. else :
  7. return False

23.前序中序求后序

  1. def rebuild(pre, center):
  2. if not pre:
  3. return
  4. cur = Node(pre[0])
  5. index = center.index(pre[0])
  6. cur.left = rebuild(pre[1:index + 1], center[:index])
  7. cur.right = rebuild(pre[index + 1:], center[index + 1:])
  8. return cur
  9.  
  10. def deep(root):
  11. if not root:
  12. return
  13. deep(root.left)
  14. deep(root.right)
  15. print root.data

24.单链表逆置

  1. class Node(object):
  2. def __init__(self, data=None, next=None):
  3. self.data = data
  4. self.next = next
  5.  
  6. link = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9)))))))))
  7.  
  8. def rev(link):
  9. pre = link
  10. cur = link.next
  11. pre.next = None
  12. while cur:
  13. tmp = cur.next
  14. cur.next = pre
  15. pre = cur
  16. cur = tmp
  17. return pre
  18.  
  19. root = rev(link)
  20. while root:
  21. print root.data
  22. root = root.next

25.两个字符串是否是变位词

  1.  

问题描述:写出一个函数 anagram(s, t) 判断两个字符串是否可以通过改变字母的顺序变成一样的字符串。

  1.  

样例

  1.  

给出 s = "abcd",t="dcab",返回 true.
给出 s = "ab", t = "ab", 返回 true.
给出 s = "ab", t = "ac", 返回 false

  1. class Anagram:
  2. """
  3. @:param s1: The first string
  4. @:param s2: The second string
  5. @:return true or false
  6. """
  7. def Solution1(s1,s2):
  8. alist = list(s2)
  9.  
  10. pos1 = 0
  11. stillOK = True
  12.  
  13. while pos1 < len(s1) and stillOK:
  14. pos2 = 0
  15. found = False
  16. while pos2 < len(alist) and not found:
  17. if s1[pos1] == alist[pos2]:
  18. found = True
  19. else:
  20. pos2 = pos2 + 1
  21.  
  22. if found:
  23. alist[pos2] = None
  24. else:
  25. stillOK = False
  26.  
  27. pos1 = pos1 + 1
  28.  
  29. return stillOK
  30.  
  31. print(Solution1('abcd','dcba'))
  32.  
  33. def Solution2(s1,s2):
  34. alist1 = list(s1)
  35. alist2 = list(s2)
  36.  
  37. alist1.sort()
  38. alist2.sort()
  39.  
  40. pos = 0
  41. matches = True
  42.  
  43. while pos < len(s1) and matches:
  44. if alist1[pos] == alist2[pos]:
  45. pos = pos + 1
  46. else:
  47. matches = False
  48.  
  49. return matches
  50.  
  51. print(Solution2('abcde','edcbg'))
  52.  
  53. def Solution3(s1,s2):
  54. c1 = [0]*26
  55. c2 = [0]*26
  56.  
  57. for i in range(len(s1)):
  58. pos = ord(s1[i])-ord('a')
  59. c1[pos] = c1[pos] + 1
  60.  
  61. for i in range(len(s2)):
  62. pos = ord(s2[i])-ord('a')
  63. c2[pos] = c2[pos] + 1
  64.  
  65. j = 0
  66. stillOK = True
  67. while j<26 and stillOK:
  68. if c1[j] == c2[j]:
  69. j = j + 1
  70. else:
  71. stillOK = False
  72.  
  73. return stillOK
  74.  
  75. print(Solution3('apple','pleap'))

class Solution:
    def anagram(self, s, t):
        m = list(s)
        n = list(t)
        m.sort()
        n.sort()
        if m == n:
            return True
        else:
            return False

26.现有字典 d= {'a':24,'g':52,'i':12,'k':33}请按value值进行排序?

  1. sorted(d.items(),key=lambda x:x[1])

27.请反转字符串 "aStr"?

  1. print("aStr"[::-1])

28.将字符串 "k:1 |k1:2|k2:3|k3:4",处理成字典 {k:1,k1:2,...}

  1. str1 = "k:1|k1:2|k2:3|k3:4"
  2. def str2dict(str1):
  3. dict1 = {}
  4. for iterms in str1.split('|'):
  5. key,value = iterms.split(':')
  6. dict1[key] = value
  7. return dict1
  8. #字典推导式
  9. d = {k:int(v) for t in str1.split("|") for k, v in (t.split(":"), )}

29.请按alist中元素的age由大到小排序

  1. alist = [{'name':'a','age':20},{'name':'b','age':30},{'name':'c','age':25}]
  2. def sort_by_age(list1):
  3. return sorted(alist,key=lambda x:x['age'],reverse=True)

30.下面代码的输出结果将是什么?

  1. list = ['a','b','c','d','e']
  2. print(list[10:])

代码将输出[],不会产生IndexError错误,就像所期望的那样,尝试用超出成员的个数的index来获取某个列表的成员。例如,尝试获取list[10]和之后的成员,会导致IndexError。然而,尝试获取列表的切片,开始的index超过了成员个数不会产生IndexError,而是仅仅返回一个空列表。这成为特别让人恶心的疑难杂症,因为运行的时候没有错误产生,导致Bug很难被追踪到。

33.写一个列表生成式,产生一个公差为11的等差数列

  1. print([x*11 for x in range(10)])

34.给定两个列表,怎么找出他们相同的元素和不同的元素?

  1. list1 = [1,2,3]
  2. list2 = [3,4,5]
  3. set1 = set(list1)
  4. set2 = set(list2)
  5. print(set1 & set2)
  6. print(set1 ^ set2)

36.给定两个list A,B ,请用找出A,B中相同与不同的元素

  1. A,B 中相同元素: print(set(A)&set(B))
  2. A,B 中不同元素: print(set(A)^set(B))

37.反转一个整数,例如-123 --> -321

  1. class Solution(object):
  2. def reverse(self,x):
  3. if -10<x<10:
  4. return x
  5. str_x = str(x)
  6. if str_x[0] !="-":
  7. str_x = str_x[::-1]
  8. x = int(str_x)
  9. else:
  10. str_x = str_x[1:][::-1]
  11. x = int(str_x)
  12. x = -x
  13. return x if -2147483648<x<2147483647 else 0
  14. if __name__ == '__main__':
  15. s = Solution()
  16. reverse_int = s.reverse(-120)
  17. print(reverse_int)

38.设计实现遍历目录与子目录,抓取.pyc文件

  1. import os
  2.  
  3. def pick(obj):
  4. if obj.endswith(".pyc"):
  5. print(obj)
  6.  
  7. def scan_path(ph):
  8. file_list = os.listdir(ph)
  9. for obj in file_list:
  10. if os.path.isfile(obj):
  11. pick(obj)
  12. elif os.path.isdir(obj):
  13. scan_path(obj)
  14.  
  15. if __name__=='__main__':
  16. path = input('输入目录')
  17. scan_path(path)

39.一行代码实现1-100之和

  1. count = sum(range(0,101))
  2. print(count)

40.Python-遍历列表时删除元素的正确做法

  1. a=[1,2,3,4,5,6,7,8]
  2. b = filter(lambda x: x>5,a)
  3. print(list(b))

41.字符串的操作题目

42.求出列表所有奇数并构造新列表

  1. a = [1,2,3,4,5,6,7,8,9,10]
  2. res = [ i for i in a if i%2==1]
  3. print(res)

43.用一行python代码写出1+2+3+10248

  1. from functools import reduce
  2. #1.使用sum内置求和函数
  3. num = sum([1,2,3,10248])
  4. print(num)
  5. #2.reduce 函数
  6. num1 = reduce(lambda x,y :x+y,[1,2,3,10248])
  7. print(num1)

44.Python中变量的作用域?(变量查找顺序)

  1. 函数作用域的LEGB顺序
  2.  
  3. 1.什么是LEGB?
  4.  
  5. L local 函数内部作用域
  6.  
  7. E: enclosing 函数内部与内嵌函数之间
  8.  
  9. G: global 全局作用域
  10.  
  11. B build-in 内置作用
  12.  
  13. python在函数里面的查找分为4种,称之为LEGB,也正是按照这是顺序来查找的

45.字符串 "123" 转换成 123,不使用内置api,例如 int()

  1. def atoi(s):
  2. num = 0
  3. for v in s:
  4. for j in range(10):
  5. if v == str(j):
  6. num = num * 10 + j
  7. return num

46.给定一个整数数组和一个目标值,找出数组中和为目标值的两个数。

你可以假设每个输入只对应一种答案,且同样的元素不能被重复利用。示例:给定nums = [2,7,11,15],target=9 因为 nums[0]+nums[1] = 2+7 =9,所以返回[0,1]

  1. class Solution:
  2. def twoSum(self,nums,target):
  3. """
  4. :type nums: List[int]
  5. :type target: int
  6. :rtype: List[int]
  7. """
  8. d = {}
  9. size = 0
  10. while size < len(nums):
  11. if target-nums[size] in d:
  12. if d[target-nums[size]] <size:
  13. return [d[target-nums[size]],size]
  14. else:
  15. d[nums[size]] = size
  16. size = size +1
  17. solution = Solution()
  18. list = [2,7,11,15]
  19. target = 9
  20. nums = solution.twoSum(list,target)
  21. print(nums)
  22.  
  23. def solution(nums,target):
  24. #新建立一个空字典用来保存数值及其在列表中对应的索引
  25. dict1 = {}
  26. #遍历一遍列表对应的时间复杂度为O(n)
  27. for i in range(0, len(nums)):
  28. #相减得到另一个数值
  29. num = target - nums[i]
  30. #如果另一个数值不在字典中,则将第一个数值及其的索引报错在字典中
  31. #因为在字典中查找的时间复杂度为O(1),因此总时间复杂度为O(n)
  32. if num not in dict1:
  33. dict1[nums[i]] = i
  34. #如果在字典中则返回
  35. else:
  36. return [dict1[num], i]

48.统计一个文本中单词频次最高的10个单词?

  1. import re
  2.  
  3. # 方法一
  4. def test(filepath):
  5.  
  6. distone = {}
  7.  
  8. with open(filepath) as f:
  9. for line in f:
  10. line = re.sub("\W+", " ", line)
  11. lineone = line.split()
  12. for keyone in lineone:
  13. if not distone.get(keyone):
  14. distone[keyone] = 1
  15. else:
  16. distone[keyone] += 1
  17. num_ten = sorted(distone.items(), key=lambda x:x[1], reverse=True)[:10]
  18. num_ten =[x[0] for x in num_ten]
  19. return num_ten
  20.  
  21. # 方法二
  22. # 使用 built-in 的 Counter 里面的 most_common
  23. import re
  24. from collections import Counter
  25.  
  26. def test2(filepath):
  27. with open(filepath) as f:
  28. return list(map(lambda c: c[0], Counter(re.sub("\W+", " ", f.read()).split()).most_common(10)))

49.请写出一个函数满足以下条件

该函数的输入是一个仅包含数字的list,输出一个新的list,其中每一个元素要满足以下条件:

1、该元素是偶数

2、该元素在原list中是在偶数的位置(index是偶数)

  1. def num_list(num):
  2. return [i for i in num if i %2 ==0 and num.index(i)%2==0]
  3.  
  4. num = [0,1,2,3,4,5,6,7,8,9,10]
  5. result = num_list(num)
  6. print(result)

50.使用单一的列表生成式来产生一个新的列表

  1. list_data = [1,2,5,8,10,3,18,6,20]
  2. res = [x for x in list_data[::2] if x %2 ==0]
  3. print(res)

51.输入某年某月某日,判断这一天是这一年的第几天?

  1. import datetime
  2.  
  3. y = int(input("请输入4位数字的年份:"))
  4. m = int(input("请输入月份:"))
  5. d = int(input("请输入是哪一天"))
  6.  
  7. targetDay = datetime.date(y,m,d)
  8. dayCount = targetDay - datetime.date(targetDay.year -1,12,31)
  9. print("%s是 %s年的第%s天。"%(targetDay,y,dayCount.days))

52.两个有序列表,l1,l2,对这两个列表进行合并不可使用extend

  1. def loop_merge_sort(l1,l2):
  2. tmp = []
  3. while len(l1)>0 and len(l2)>0:
  4. if l1[0] <l2[0]:
  5. tmp.append(l1[0])
  6. del l1[0]
  7. else:
  8. tmp.append(l2[0])
  9. del l2[0]
  10. while len(l1)>0:
  11. tmp.append(l1[0])
  12. del l1[0]
  13. while len(l2)>0:
  14. tmp.append(l2[0])
  15. del l2[0]
  16. return tmp

53.给定一个任意长度数组,实现一个函数
让所有奇数都在偶数前面,而且奇数升序排列,偶数降序排序,如字符串'1982376455',变成'1355798642'

  1. # 方法一
  2. def func1(l):
  3. if isinstance(l, str):
  4. l = [int(i) for i in l]
  5. l.sort(reverse=True)
  6. for i in range(len(l)):
  7. if l[i] % 2 > 0:
  8. l.insert(0, l.pop(i))
  9. print(''.join(str(e) for e in l))

54.写一个函数找出一个整数数组中,第二大的数

  1. def find_second_large_num(num_list):
  2. """
  3. 找出数组第2大的数字
  4. """
  5. # 方法一
  6. # 直接排序,输出倒数第二个数即可
  7. tmp_list = sorted(num_list)
  8. print("方法一\nSecond_large_num is :", tmp_list[-2])
  9.  
  10. # 方法二
  11. # 设置两个标志位一个存储最大数一个存储次大数
  12. # two 存储次大值,one 存储最大值,遍历一次数组即可,先判断是否大于 one,若大于将 one 的值给 two,将 num_list[i] 的值给 one,否则比较是否大于two,若大于直接将 num_list[i] 的值给two,否则pass
  13. one = num_list[0]
  14. two = num_list[0]
  15. for i in range(1, len(num_list)):
  16. if num_list[i] > one:
  17. two = one
  18. one = num_list[i]
  19. elif num_list[i] > two:
  20. two = num_list[i]
  21. print("方法二\nSecond_large_num is :", two)
  22.  
  23. # 方法三
  24. # 用 reduce 与逻辑符号 (and, or)
  25. # 基本思路与方法二一样,但是不需要用 if 进行判断。
  26. from functools import reduce
  27. num = reduce(lambda ot, x: ot[1] < x and (ot[1], x) or ot[0] < x and (x, ot[1]) or ot, num_list, (0, 0))[0]
  28. print("方法三\nSecond_large_num is :", num)
  29.  
  30. if __name__ == '__main___':
  31. num_list = [34, 11, 23, 56, 78, 0, 9, 12, 3, 7, 5]
  32. find_second_large_num(num_list)

55.统计一段字符串中字符出现的次数

  1. # 方法一
  2. def count_str(str_data):
  3. """定义一个字符出现次数的函数"""
  4. dict_str = {}
  5. for i in str_data:
  6. dict_str[i] = dict_str.get(i, 0) + 1
  7. return dict_str
  8. dict_str = count_str("AAABBCCAC")
  9. str_count_data = ""
  10. for k, v in dict_str.items():
  11. str_count_data += k + str(v)
  12. print(str_count_data)
  13.  
  14. # 方法二
  15. from collections import Counter
  16.  
  17. print("".join(map(lambda x: x[0] + str(x[1]), Counter("AAABBCCAC").most_common())))

python面试题五:Python 编程的更多相关文章

  1. 千万不要错过这几道Python面试题,Python面试题No16

    第1题: python下多线程的限制以及多进程中传递参数的方式? python多线程有个全局解释器锁(global interpreter lock),简称GIL,这个GIL并不是python的特性, ...

  2. Python面试题之Python面试题汇总

    在这篇文章中: Python基础篇 1:为什么学习Python 2:通过什么途径学习Python 3:谈谈对Python和其他语言的区别 Python的优势: 4:简述解释型和编译型编程语言 5:Py ...

  3. python面试题之Python支持什么数据类型?

    所属网站分类: 面试经典 > python 作者:外星人入侵 链接:http://www.pythonheidong.com/blog/article/67/ 来源:python黑洞网,专注py ...

  4. python面试题三:Python 网络编程与并发

    1 简述 OSI 七层协议. OSI七层协议模型主要是: 应用层(Application):为用户的应用程序(例如电子邮件.文件传输和终端仿真)提供网络服务. 表示层(Presentation):使用 ...

  5. Python面试题之Python面向对象编程汇总

    面向对象的设计思想是从自然界中来的,因为在自然界中,类(Class)和实例(Instance)的概念是很自然的.Class是一种抽象概念,比如我们定义的Class——Student,是指学生这个概念, ...

  6. python 基础(十五) socket编程

    SOCKET TCP协议: 有请求 有响应 称之为 tcp协议 是面向连接的协议 就是在收发数据之前 必须先要建立一个可靠的链接 三次握手 如:网站 UDP协议: 是一个非链接的协议 传输之前不需要键 ...

  7. Python面试题之python是一种什么语言及优缺点

    1.说说python是一种什么语言? 参考答案:python是一门动态解释性的强类型定义语言 编译型vs解释型 编译型优点:编译器一般会有预编译的过程对代码进行优化.因为编译只做一次,运行时不需要编译 ...

  8. python面试题之Python 的特点和优点是什么

    Python 可以作为编程的入门语言,因为他具备以下特质: 1. 解释性 2. 动态特性 3. 面向对象 4. 语法简洁 5. 开源 6. 丰富的社区资源 7 库丰富 文章转载自Python黑洞网

  9. python面试题二:Python 基础题

    1.位和字节的关系? Byte 字节 bit 位 1Byte = 8bit 2.b.B.KB.MB.GB 的关系? 1Byte = 8bit KB 1KB=1024B MB 1MB=1024KB GB ...

随机推荐

  1. LR字符串处理函数-lr_save_string

    int lr_save_string( const char *param_value, const char *param_name) 指定字符串保存至参数 Action() { lr_save_s ...

  2. Android学习笔记使用AlertDialog实现对话框

    使用AlertDialog可以实现如下对话框 案例 布局问文件就加了几个Button,我直接上Java代码了 实现显示带取消,确定按钮的对话框按钮 Button showDialogOne = fin ...

  3. ca72a_c++_标准IO库:面向对象的标准库

    /*ca72a_c++_标准IO库:面向对象的标准库继承:基类->派生类3个头文件9个标准库类型IO对象不可复制或赋值 ofstream, f--file,文件输出流ostringstream, ...

  4. 键盘侠Linux教程(四)| 常用命令

    前言 Linux命令并不可怕,只要熟悉日常的操作命令即可,其他不熟悉的命令,需要用到的时候可以查阅资料,熟能生巧. Linux常用操作命令 命令的基本格式 命令的提示符 [root@localhost ...

  5. TiDB初探

    TiDB是一个开源的分布式NewSQL数据库,设计的目标是满足100%的OLTP和80%的OLAP,支持SQL.水平弹性扩展.分布式事务.跨数据中心数据强一致性保证.故障自恢复的高可用.海量数据高并发 ...

  6. JavaWeb网上图书商城完整项目--day02-15.登录功能流程分析

    当用户点击登录界面的登录按钮的时候,将登录的用户名.密码和验证码上传到后台,后台的业务流程如下面所示:

  7. SpringBoot--使用redis实现分布式限流

    1.引入依赖 <!-- 默认就内嵌了Tomcat 容器,如需要更换容器也极其简单--> <dependency> <groupId>org.springframew ...

  8. MySQL 字符串索引优化方案

    字符串建立索引的优化 1. 建立前缀索引 假设建立一个支持邮箱登录的用户表,对于邮件字段来说,可以有以下几种建立索引的方式: 直接对整个字符串建立索引 alter table SUser add in ...

  9. apache frpClien操作报错解决

    #打开配置文件vim /etc/vsftpd/vsftpd.conf #修改配置100行chroot_local_user=NO

  10. Tomcat的介绍

    Tomcat简介 Tomcat 服务器是一个免费的开放源代码的Web 应用服务器,属于轻量级应用服务器,在中小型系统和并发访问用户不是很多的场合下被普遍使用,是开发和调试JSP 程序的首选. 支持Se ...