# 1.3 常见问题求解

1、斐波拉契数列

```python
def febo(num):
    list_ = []
    i = 1
    j = 0
    while len(list_) < num:
        list_.append(i)
        i, j = i + j, i
    return list_
```

```python
class Febo:
    def __init__(self):
        self.i = 1
        self.j = 0
        self.times = 0
    def __iter__(self):
        return self

    def __next__(self):
        self.times += 1
        self.i,self.j = self.i+self.j, self.i
        return self.j
```

2、浅拷贝和深拷贝

* 浅拷贝仅仅复制了容器中元素的地址

```python
>>> a=['hello',[1,2,3]]
>>> b=a[:]
>>> [id(x) for x in a]
[55792504, 6444104]
>>> [id(x) for x in b]
[55792504, 6444104]
>>> a[0]='world'
>>> a[1].append(4)
>>> print(a)
['world', [1, 2, 3, 4]]
>>> print(b)
['hello', [1, 2, 3, 4]]
```

这里可以看出，未修改前，a和b中元素的地址都是相同的，不可变的hello\
。和可变的list地址都一样，说明浅拷贝知识将容器内的元素的地址复制了一份。这可以通过修改后，b中字符串没改变，但是list元素随着a相应改变得到验证。（新瓶装旧酒）

* 深拷贝，完全拷贝了一个副本，容器内部元素地址都不一样

```python
>>> from copy import deepcopy
>>> a=['hello',[1,2,3]]
>>> b=deepcopy(a)
>>> [id(x) for x in a]
[55792504, 55645000]
>>> [id(x) for x in b]
[55792504, 58338824]
>>> a[0]='world'
>>> a[1].append(4)
>>> 
>>> print(a)
['world', [1, 2, 3, 4]]
>>> print(b)
['hello', [1, 2, 3]]
```

这里可以看出，深拷贝后，a和b的地址以及a和b中的元素地址均不同，这是完全拷贝的一个副本，修改a后，发现b没有发生任何改变，因为b是一个完全的副本，元素地址与a均不同，a修改不影响b。（新瓶装新酒）

3、列表当队列、栈

```
stack = []
for x in range(1,6):
    stack.append(x)   # 入栈
    print('push', x, end=' ')
    print(stack)

print('Now stack is', stack)

while len(stack)>0:
    print('pop', stack.pop(), end=' ') # 出栈
    print(stack)
```

```
from collections import deque
queue = deque()       # 创建空队列
for x in range(1,6):
    queue.append(x)   # 入队
    print('push', x, end=' ')
    print(list(queue))

print('Now queue is', list(queue))

while len(queue)>0:
    print('pop', queue.popleft(), end=' ')  # 出队
    print(list(queue))
```

4、单例模式

每个类只有一个实例存在

* 使用模块
* 使用初始化方法（看不懂，不会无限迭代吗？）

```python
class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kw)  
        return cls._instance  

class MyClass(Singleton):  
    a = 1
```

5、全局变量

global 和 globals() 是不同的，global 是关键字用来声明一个局部变量为全局变量。globals() 和 locals() 提供了基于字典的访问全局和局部变量的方式

快速排序

深度遍历、广度遍历

时间复杂度

求解质数

鸭子模式

文件I/O(输入输出)
