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和函数的执行流程，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))
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)