python高级------拷贝、列表推导式、生成器、迭代器、装饰器、闭包！

==和is

== 是比较两个对象是否相等。
is 是比较两个引用是否指向了同一个对象（引用比较）。

深拷贝和浅拷贝

1. copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象。
2. copy.deepcopy 深拷贝 拷贝对象及其子对象

 import copy
>>> a = [1,2,3,4,['a','b']] #定义一个列表a
>>> b = a #赋值
>>> c = copy.copy(a) #浅拷贝
>>> d = copy.deepcopy(a) #深拷贝

>>> a.append(5)
>>> print(a)
[1, 2, 3, 4, ['a', 'b'], 5] #a添加一个元素5
>>> print(b) 
[1, 2, 3, 4, ['a', 'b'], 5] #b跟着添加一个元素5 
>>> print(c)
[1, 2, 3, 4, ['a', 'b']] #c保持不变
>>> print(d)
[1, 2, 3, 4, ['a', 'b']] #d保持不变

>>> a[4].append('c') 
>>> print(a)
[1, 2, 3, 4, ['a', 'b', 'c'], 5] #a中的list(即a[4])添加一个元素c
>>> print(b)
[1, 2, 3, 4, ['a', 'b', 'c'], 5] #b跟着添加一个元素c
>>> print(c)
[1, 2, 3, 4, ['a', 'b', 'c']] #c跟着添加一个元素c
>>> print(d)
[1, 2, 3, 4, ['a', 'b']] #d保持不变

#说明如下：
#1.外层添加元素时， 浅拷贝c不会随原列表a变化而变化；内层list添加元素时，浅拷贝c才会变化。
#2.无论原列表a如何变化，深拷贝d都保持不变。
#3.赋值对象随着原列表一起变化

列表推导式

列表推导能非常简洁的构造一个新列表:只用一条简洁的表达式即可对得到的元素进行转换变形

a = [x for x in renge(4)]
print(a)

输出的结果为

[0,1,2,3]

在循环的过程中使用if

a = [x for x in range (3,10) if x%2 == 0]

输出的结果为

[4,6,8]

生成器

创建生成器方法1

要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( )

In [15]: L = [ x*2 for x in range(5)]

In [16]: L
Out[16]: [0, 2, 4, 6, 8]

In [17]: G = ( x*2 for x in range(5))

In [18]: G
Out[18]: <generator object <genexpr> at 0x7f626c132db0>

In [19]:
```创建生成器方法2
```python3
In [30]: def fib(times):
....: n = 0
....: a,b = 0,1
....: while n<times:
....: yield b
....: a,b = b,a+b
....: n+=1
....: return 'done'
....:

In [31]: F = fib(5)

In [32]: next(F)
Out[32]: 1

In [33]: next(F)
Out[33]: 1

In [34]: next(F)
Out[34]: 2

In [35]: next(F)
Out[35]: 3

In [36]: next(F)
Out[36]: 5

In [37]: next(F)

集合

集合是一个无序的，不重复的数据组合.

迭代器

迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。

可迭代对象

以直接作用于 for 循环的数据类型有以下几种：
一类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；
一类是 generator ，包括生成器和带 yield 的generator function。
这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable 。

判断是否可以迭代

可以使用 isinstance() 判断一个对象是否是 Iterable 对象：

In [50]: from collections import Iterable

In [51]: isinstance([], Iterable)
Out[51]: True

In [52]: isinstance({}, Iterable)
Out[52]: True

In [53]: isinstance('abc', Iterable)
Out[53]: True

In [54]: isinstance((x for x in range(10)), Iterable)
Out[54]: True

In [55]: isinstance(100, Iterable)
Out[55]: False

迭代器

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

In [56]: from collections import Iterator

In [57]: isinstance((x for x in range(10)), Iterator)
Out[57]: True

In [58]: isinstance([], Iterator)
Out[58]: False

In [59]: isinstance({}, Iterator)
Out[59]: False

In [60]: isinstance('abc', Iterator)
Out[60]: False

In [61]: isinstance(100, Iterator)
Out[61]: False

iter()函数

生成器都是 Iterator 对象，但 list 、 dict 、 str 虽然是 Iterable ，却不是 Iterator

In [62]: isinstance(iter([]), Iterator)
Out[62]: True

In [63]: isinstance(iter('abc'), Iterator)
Out[63]: True

闭包

什么是闭包

1.def test(number):
2. #在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包
3. def test_in(number_in):
4. print("in test_in 函数, number_in is %d"%number_in)
5. return number+number_in
6. #其实这里返回的就是闭包的结果
7. return test_in

装饰器

装饰器是程序开发中经常会用到的一个功能，所谓装饰器就是把函数包装一下,为函数添加一些附加功能,装饰器就是一个函数,参数为被包装的函数。
pyrhon3写代码要遵循开放封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：
* 封闭：已实现的功能代码块
* 开放：对扩展开发

    def inner():
        # 验证1
        # 验证2
        # 验证3
        func()
    return inner
@w1
def f1():
    print('f1')
@w1
def f2():
    print('f2')
@w1
def f3():
    print('f3')
@w1
def f4():
    print('f4')