1.列表两个数和等于目标数就返回这两个数下标：

  • 方法一： ```python def twoSum(nums, target): result = []

    使用enumerate返回一个可迭代的列索引和值的对象(0, seq[0]), (1, seq[1])

    for index, value in enumerate(nums):
    1. next_index=index+1
    2. #判断目标数与value的差是否在目标列表nums,范围从index+1开始
    3. if target - value in nums[next_index:]:
    4.      #符合条件就返回索引和下一个能组和成目标数的value的index
    5.      #加上next_index，是因为target - value的索引是针对于新
    6.      #列表nums[next_index:]中的位置，不是原列表nums位置,so
    7.      #加上原来开始的位置next_index
    8.      result.append([index, nums[next_index:].index(target - value) + next_index])
    return result

nums = [2, 11, 7, 15, 3, 6, 0, 9] target = 9 print(twoSum(nums, target))

运行结果[[0, 2], [4, 5], [6, 7]]

  2. - 方法二：使用双层for循环 效率较低但是易于理解
  3. ```python
  5.     result=[]
  6.     for i in range(len(nums)):
  7.         for j in range(i+1,len(nums)):
  8.             if target==nums[i]+nums[j]:
  9.                 result.append(i)
  10.                 result.append(j)
  11.                 return result

2.垃圾回收机制：

  • 引用计数
  • 分代回收
  • 标记清除

3.斐波那契数列：

  • 方法一：递归方法 ```python def fib_recur(n): if n<=1:
    1.   return n
    else:
    1.   return fib_recur(n-1)+fib_recur(n-2)

def ex(c): return int(c)

for i in range(1,10): print(fib_recur(i),end=’ ‘)

返回结果：1 1 2 3 5 8 13 21 34

  2. - 方法二：**递推方法**
  3. ```python
  4. def fib_loop(n):
  5.     a,b=0,1
  6.     for i in range(n+1):
  7.         a,b=b,a+b
  8.     return a
  11. for i in range(20):
  12.     print(fib_loop(i),end=' ')
  13. #输出结果：1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765
  • 方法三：生成器 ```python def fib_loop_while(n): a,b=0,1 for i in range(0,n):
    1.   a,b=b,a+b
    2.   yield a

for i in fib_loop_while(5): print(i,end=’ ‘)

输出结果：1 1 2 3 5

1、带有yield关键字的函数对象 他是返回一个列表list，list中的每个元素 都是 yield返回的每一个值 （每次执行yield输出值构成的列表）

2、带有yield的函数都被看成生成器，生成器是可迭代对象，且具备iter 和 next方法， 可以遍历获取元素

  1. **4.字符串消消乐，相邻的两个字符串如果一致就消掉：**<br />例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。<br />之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
  2. ```python
  3. S = 'abbaca'
  4. st = []
  6. #对于字符串做遍历，如果st为空就把字符串遍历出的元素i加入
  7. #如果遍历出的元素=列表st的倒数第一个元素就移除列表中的一
  8. #个元素(默认最后一个)否则就将元素加入列表st
  9. for i in S:
  11.     if len(st) == 0:
  12.         st.append(i)
  13.     elif i == st[-1]:
  14.         st.pop()
  15.     else:
  16.         st.append(i)
  17. print("".join(st))

5.找出一个字符串中子串，不含有重复字符的最长子串：

  1. def lengthOfLongestSubstring( s):
  3.     st = {}
  4.     i, ans = 0, 0
  5.     for j in range(len(s)):
  6.         #当索引为j字符在st字典中时
  7.         if s[j] in st:
  8.             #i取(st[s[j]], i)中的最大值，其中st[s[j]]为该字符(也就是st中的key)在st中所对应的值
  9.             i = max(st[s[j]], i)
  10.             print(s[j],st[s[j]],i)
  11.         #索引为j字符不在st中也就是不重复时，j-i+1(看作j+1-i)等价于其字符的位置减去st中在该字符出现重复时
  12.         #在字符串上一次出现的位置(例第三次出现重复时，上一次也就是第二次出现的位置)
  13.         ans = max(ans, j - i + 1)
  14.         #字符串中索引为j字符在字符串中的位置
  15.         st[s[j]] = j + 1
  16.     return ans
  19. print(lengthOfLongestSubstring('abcabcdbb'))
  22. #输出结果为：
  23. a 1 1
  24. b 2 2
  25. c 3 3
  26. b 5 5
  27. b 8 8
  28. 4