# 面试题
```python
def num():
return [lambda x: i*x for i in range(4)]
print([m(2) for m in num()]) # 输出: [6, 6, 6, 6]
```
### 思路：
这题涉及到了闭包延时绑定，当循环执行完了之后才会执行传参，循环四次，每一次循环完 i=3 然后再和x相乘 所以结果是6，6，6，6。 如果把 [ lambda x: i*x for i in range(4) ] 改成 （ lambda x: i*x for i in range(4) ）这样就变成了一个生成器 自动实现迭代器协议，一边循环一边计算的机制， 这样结果就是 0，2，4，6.
---
## 两数之和
```
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
```
### 思路：
这里可以使用字典来解题，通过enumerate方法遍历获取数据的下标包括对应值，然后以key，value形式把该数据的下标和对应值存入字典，然后再出通过enumerate方法遍历数据，每一次获取数据就从字典拿出一个值，用目标值减去从字典拿出的这个值得到一个结果值，如果结果值存在字典当中，那么返回两个数的下标，如果为None，说明字典中没有这个值。
### 实现代码：
```python
def get_index_list(nums, target):
# Todo 作为一个方法来实现，批量解决这个获取索引的问题
"""
:params nums：传的参数的列表
:params target: 目标值
:return: 返回索引
"""
dic = {}
for a, b in enumerate(nums): # a是下标 b是对应值
dic[b] = a # 对应值存入字典
for i, b in enumerate(nums):
j = dic.get(target-b) # 从字典中拿出对应值 用目标值减去对应值
if j is not None: # 判断如果减去的对应值不为空，则返回下标
return [i, j]
```
---
## 数组中重复的数字
示例：
```python
输入:
[2,3,1,0,2,5,3]
输出: 2 或 3
```
### 思路：
这道题想到的是，使用列表中的count方法，定义一个空列表，遍历数据然后进行判断，如果数据值出现个数大于或等于2，说明该数据是重复的，然后把重复的筛取出来之后存入空列表，再进行返回输出。
### 实现代码：
```python
def get_number(nums):
"""
:params nums：传的参数的数组
:return: 返回重复数字
"""
nub = []
for i in nums:
if nums.count(i) >= 2:
if str(i) not in nub:
nub.append(str(i))
print('或'.join(nub))
if __name__ == "__main__":
get_number([2, 3, 1, 0, 2, 5, 3])
```
## 队列实现一个栈
### 思路：
使用一个队列，实现栈的一些基本操作，栈（后进先出）的特性。
### 实现代码：
```python
# 队列实现一个栈 （栈：后进先出）
class Stack(object):
def __init__(self):
# 定义一个队列
self.lst = []
def is_None(self):
# 判断栈是否为空 返回 ture false
return self.lst == []
def push(self, i):
# 加入元素
self.lst.append(i)
def pop(self):
# 出栈
return self.lst.pop()
def stack_top(self):
# 返回栈顶元素
return self.lst[-1]
def size(self):
# 栈的大小
return len(self.lst)
if __name__ == "__main__":
stack = Stack()
print(stack.is_None())
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.lst)
print(stack.pop())
print(stack.stack_top())
print(stack.size())
```
---
## 回文数
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例1：
```python
输入: 121
输出: true
```
示例2：
```python
输入: -121
输出: false
解释: 从左向右，为 -121 。 从右向左读，为121- 。 因此它不是一个回文数
```
示例3：
```
输入: 10
输出: false
解释: 从右向左读，为 01 。 因此它不是一个回文数
```
### 思路：
这题可以使用字符串 双指针的方法 将数据转化为字符串 首先定义好第一个元素下标和最后一个元素下标，while循环 只要条件不满足 一直循环 循环判断第一个和最后一个元素是否相等 不相等返回false 相等继续循环，如果循环条件满足之后都相等，返回 false
### 实现代码：
```python
def palindromic_number(x):
"""
:params x：传的参数的列表
:return: 返回Ture False
"""
lst = list(str(x))
print(lst)
L, R = 0, len(lst)-1
while L <= R:
print(L, R)
if lst[L] != lst[R]:
return False
L += 1
R -= 1
return True
if __name__ == "__main__":
print(palindromic_number(1231))
```
---
## 分别用生成器和迭代器生成斐波那契数列
示例：
```
输出: 1 1 2 3 5 8 13
```
```python
# 使用迭代器生成斐波那契数列
class Fibonacii(object):
def __init__(self,all_num):
self.all_num = all_num
self.cur_idx = 0
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
if self.cur_idx >= self.all_num:
raise StopIteration
ret = self.a
self.a, self.b = self.b, self.a + self.b
self.cur_idx += 1
return ret
fibo = Fibonacii(10)
for i in fibo:
print(i)
```
```python
# 使用生成器生成斐波那契数列
def fibnacii(count):
num = 0
a, b = 0, 1
while num < count:
yield a
a, b = b, a+b
num += 1
fi = fibnacii(10)
for i in fi:
print(i)
```
## 反转字符数组
### 思路：
直接使用反转
### 实现代码：
```python
# 反转字符串
def reverseString(s):
s[0::] = s[::-1]
print(s)
if __name__ == "__main__":
reverseString(['b', '', 'a', 'r'])
```
#字符串反转
# a="Let's take LeetCode contest"
# def b():
# return ' '.join(a.split(' ')[::-1])[::-1]
# if __name__ == '__main__':
# print(b())
#球的题
# def a():
# slit=[]
# s=100
# for c in range(0,10):
# if c==0:
# slit.append(s)
# else:
# slit.append(s*2)
# s=s/2
# print(sum(slit))
# print(s)
# if __name__ == '__main__':
# a()
#冒泡排序
#定义一个函数传入个变量
# def bubble_sort(li):
# for i in range(len(li)-1):
# for j in range(len(li)-i-1):
# if li[j] > li[j+1]:
# li[j],li[j+1]=li[j+1],li[j]
#
# li = [1,5,2,6,3,7,4,8,9,0]
# bubble_sort(li)
# print(li)