Python中的赋值(复制)、浅拷贝、深拷贝之间的区别

1.赋值: 只是复制了新对象的引用，不会开辟新的内存空间。
2.浅拷贝: 创建新对象，其内容是原对象的引用
浅拷贝有三种形式：1.切片操作 2.工厂函数 3.copy模块中的copy函数。

切片操作：lst1 = lst[:] 或者 lst1 = [each for each in lst]
工厂函数：lst1 = list(lst)
copy函数：lst1 = copy.copy(lst)
浅拷贝之所以称为浅拷贝，是它仅仅只拷贝了一层，在lst中有一个嵌套的list[4,5]，如果我们修改了它，情况就不一样了。

3.深拷贝：只有一种形式，copy模块中的deepcopy函数。
和浅拷贝对应，深拷贝拷贝了对象的所有元素，包括多层嵌套的元素。
深拷贝出来的对象是一个全新的对象，不再与原来的对象有任何关联。

说明:
1.赋值对象随着原列表一起变化

2.外层添加元素时， 浅拷贝不会随原列表变化而变化；内层list添加元素时，浅拷贝才会变化

3.无论原列表a如何变化，深拷贝都保持不变

---

统计list中各个元素出现的次数

1.第一种方法
利用字典dict来完成统计
a = [1, 2, 3, 1, 1, 2]
dict = {}
for key in a:
    dict[key] = dict.get(key, 0) + 1
print dict

2.第二种方法
利用Python的collection包下Counter的类
from collections import Counter
a = [1, 2, 3, 1, 1, 2]
result = Counter(a)
print result

3.第三种方法
Python的pandas包下的value_counts方法
mport pandas as pd
a = [1, 2, 3, 1, 1, 2]
result = pd.value_counts(a)
print result

---

什么是生成器？（generator)

在Python中，不必创建完整的list，节省大量的空间，这种一边循环一边计算的机制，称为生成器：generator
生成器是一个特殊的程序，可以被用作控制循环的迭代行为，python中生成器是迭代器的一种，使用yield返回值函数，每次调用yield会暂停，而可以使用next()函数和send()函数恢复生成器。

生成器类似于返回值为数组的一个函数，这个函数可以接受参数，可以被调用，但是，不同于一般的函数会一次性返回包括了所有数值的数组，生成器一次只能产生一个值，这样消耗的内存数量将大大减小，而且允许调用函数可以很快的处理前几个返回值，因此生成器看起来像是一个函数，但是表现得却像是迭代器

要创建一个generator，有很多种方法，第一种方法很简单，只有把一个列表生成式的[]中括号改为（）小括号，就创建一个generator
#列表生成式
lis = [x*x for x in range(10)]
print(lis)
#生成器
generator_ex = (x*x for x in range(10))
print(generator_ex)
可以用for循环和next(生成器)把值打印出来

著名的斐波那契数列，除第一个和第二个数外，任何一个数都可以由前两个相加得到
def fib(max):
    n,a,b =0,0,1
    while n < max:
        a,b =b,a+b
        n = n+1
        print(a)
    return 'done'
a,b = b ,a+b  其实相当于 t =a+b ,a =b ,b =t  ，所以不必写显示写出临时变量t
就可以输出斐波那契数列的前N个数字

仔细观察，可以看出，fib函数实际上是定义了斐波拉契数列的推算规则，可以从第一个元素开始，
推算出后续任意的元素，这种逻辑其实非常类似generator。

也就是说上面的函数也可以用generator来实现，上面我们发现，print(b)每次函数运行都要打印，
占内存，所以为了不占内存，我们也可以使用生成器，这里叫yield。如下：
def fib(max):
    n,a,b =0,0,1
    while n < max:
        yield b
        a,b =b,a+b
        n = n+1
    return 'done'
a = fib(10)
print(fib(10))

但是返回的不再是一个值，而是一个生成器：
<generator object fib at 0x000001C03AC34FC0>

那么这样就不占内存了，这里说一下generator和函数的执行流程，generator的函数，在每次
调用next()的时候执行，遇到yield语句返回，再次被next（）调用时候从上次的返回yield语句
处急需执行，也就是用多少，取多少，不占内存。

print(a.__next__())
print("可以顺便干其他事情")
print(next(a))

生成器表达式来源于迭代和列表解析的组合，生成器和列表解析类似，但是它使用尖括号而不是方括号
# 列表解析生成列表
 [ x ** 3 for x in range(5)]
 [0, 1, 8, 27, 64]

 # 生成器表达式
 (x ** 3 for x in range(5))
 <generator object <genexpr> at 0x000000000315F678>

 # 两者之间转换
list(x ** 3 for x in range(5))
[0, 1, 8, 27, 64]
生成器的迭代器就是生成器本身

迭代器（Iterator）

迭代就是循环

我们已经知道，可以直接作用于for循环的数据类型有以下几种：
一类是集合数据类型，如list,tuple,dict,set,str等
一类是generator，包括生成器和带yield的generator function
这些可以直接作用于for 循环的对象统称为可迭代对象：Iterable
可以使用isinstance()判断一个对象是否为可Iterable对象

from collections import Iterable
>>>isinstance([], Iterable)
True
>>>isinstance({}, Iterable)
True
>>>isinstance(100, Iterable)
False

可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。

而生成器不但可以作用于for循环，还可以被next()函数不断调用并返回下一个值，直到最后抛出
StopIteration错误表示无法继续返回下一个值了。

生成器都是Iterator对象，但list、dict、str虽然是Iterable（可迭代对象），却不是Iterator（迭代器）

把list、dict、str等Iterable变成Iterator可以使用iter()函数：
>>> isinstance(iter([]), Iterator)
True
>>> isinstance(iter('abc'), Iterator)
True

你可能会问，为什么list、dict、str等数据类型不是Iterator？

这是因为Python的Iterator对象表示的是一个数据流，Iterator对象可以被next()函数调用并不断返回下一个数据，直到没有数据时抛出StopIteration错误。可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，只能不断通过next()函数实现按需计算下一个数据，所以Iterator的计算是惰性的，只有在需要返回下一个数据时它才会计算。
Iterator甚至可以表示一个无限大的数据流，例如全体自然数。而使用list是永远不可能存储全体自然数的

from collections import Iterator  #迭代器
from collections import Iterable  #可迭代对象
 
print(isinstance(s,Iterator))     #判断是不是迭代器
print(isinstance(s,Iterable))       #判断是不是可迭代对象

#把可迭代对象转换为迭代器
print(isinstance(iter(s),Iterator))

小结：

1.凡是可作用于for循环的对象都是Iterable(可迭代对象)类型；
2.凡是可作用于next()函数的对象都是Iterator(迭代器)类型，它们表示一个惰性计算的序列；
3.集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。

Python3的for循环本质上就是通过不断调用next()函数实现的，例如：

for x in [1, 2, 3, 4, 5]:
    pass

实际上完全等价于

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

对yield的总结
（1）：通常的for..in...循环中，in后面是一个数组，这个数组就是一个可迭代对象，类似的还有链表，字符串，文件。他可以是a = [1,2,3]，也可以是a = [x*x for x in range(3)]。

它的缺点也很明显，就是所有数据都在内存里面，如果有海量的数据，将会非常耗内存。

（2）生成器是可以迭代的，但是只可以读取它一次。因为用的时候才生成，比如a = (x*x for x in range(3))。!!!!注意这里是小括号而不是方括号。

（3）生成器（generator）能够迭代的关键是他有next()方法，工作原理就是通过重复调用next()方法，直到捕获一个异常。

（4）带有yield的函数不再是一个普通的函数，而是一个生成器generator，可用于迭代

（5）yield是一个类似return 的关键字，迭代一次遇到yield的时候就返回yield后面或者右面的值。而且下一次迭代的时候，从上一次迭代遇到的yield后面的代码开始执行

（6）yield就是return返回的一个值，并且记住这个返回的位置。下一次迭代就从这个位置开始。

（7）带有yield的函数不仅仅是只用于for循环，而且可用于某个函数的参数，只要这个函数的参数也允许迭代参数。

（8）send()和next()的区别就在于send可传递参数给yield表达式，这时候传递的参数就会作为yield表达式的值，而yield的参数是返回给调用者的值，也就是说send可以强行修改上一个yield表达式值。

（9）send()和next()都有返回值，他们的返回值是当前迭代遇到的yield的时候，yield后面表达式的值，其实就是当前迭代yield后面的参数。

（10）第一次调用时候必须先next（）或send（）,否则会报错，send后之所以为None是因为这时候没有上一个yield，所以也可以认为next（）等同于send(None)

生成器实际上是特殊的一种迭代器，即完全可以像使用迭代器一样使用生成器

生成器和迭代器两者的区别

迭代器（多迭代）：可以多次迭代
myiterator = [x*x for x in range(3)]
>>> for x in myiterator:
...     print(x)

生成器（单迭代）：只能迭代一次

>>> mygenerator = (x*x for x in range(3))
>>> for x in  mygenerator:
...     print(x)