做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。
别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。
我先来介绍一下这些东西怎么用，文末抱走。
（1）Python所有方向的学习路线（新版）
这是我花了几天的时间去把Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
最近我才对这些路线做了一下新的更新，知识体系更全面了。
（2）Python学习视频
包含了Python入门、爬虫、数据分析和web开发的学习视频，总共100多个，虽然没有那么全面，但是对于入门来说是没问题的，学完这些之后，你可以按照我上面的学习路线去网上找其他的知识资源进行进阶。
（3）100多个练手项目
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了，只是里面的项目比较多，水平也是参差不齐，大家可以挑自己能做的项目去练练。
（4）200多本电子书
这些年我也收藏了很多电子书，大概200多本，有时候带实体书不方便的话，我就会去打开电子书看看，书籍可不一定比视频教程差，尤其是权威的技术书籍。
基本上主流的和经典的都有，这里我就不放图了，版权问题，个人看看是没有问题的。
（5）Python知识点汇总
知识点汇总有点像学习路线，但与学习路线不同的点就在于，知识点汇总更为细致，里面包含了对具体知识点的简单说明，而我们的学习路线则更为抽象和简单，只是为了方便大家只是某个领域你应该学习哪些技术栈。
（6）其他资料
还有其他的一些东西，比如说我自己出的Python入门图文类教程，没有电脑的时候用手机也可以学习知识，学会了理论之后再去敲代码实践验证，还有Python中文版的库资料、MySQL和HTML标签大全等等，这些都是可以送给粉丝们的东西。
这些都不是什么非常值钱的东西，但对于没有资源或者资源不是很好的学习者来说确实很不错，你要是用得到的话都可以直接抱走，关注过我的人都知道，这些都是可以拿到的。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
迭代器 ) 返回。
看一些例子。
1. >>> even_num = list ( filter ( lambda x : x % 2 == 0 , [ 1 , 2 , 3 , 4 , 5 , 6 ]))
2. >>> even_num
3. [ 2 , 4 , 6 ]
4. >>> odd_num = list ( filter ( lambda x : x % 2 , [ 1 , 2 , 3 , 4 , 5 , 6 ]))
5. >>> odd_num
6. [ 1 , 3 , 5 ]
7. >>> filter ( lambda x : x < ‘g’ , ‘hijack’ )
8. ‘ac’ # python2
9. >>> filter ( lambda x : x < ‘g’ , ‘hijack’ )
10. < filter object at 0x1034b4080 > # python3
注意在 python2 和 python3 中， map/reduce/filter 的返回值类型有所不同， python2
返回的是基本数据类型，而 python3 则返回了迭代器；
5 闭包
5.1 定义
在 Python 中，函数也是一个对象。因此，我们在定义函数时，可以再嵌套定义一个函数，并将该嵌套函数返回，比如：
1. from math import pow
3. def make_pow ( n ):
4. def inner_func ( x ): # 嵌套定义了 inner_func
5. return pow ( x , n ) # 注意这里引用了外部函数的 n
6. return inner_func # 返回 inner_func
上面的代码中，函数 make_pow 里面又定义了一个内部函数 inner_func ，然后将该函数返
回。因此，我们可以使用 make_pow 来生成另一个函数：
1. >>> pow2 = make_pow ( 2 ) # pow2 是一个函数，参数 2 是一个自由变量
2. >>> pow2
3. < function inner_func at 0x10271faa0 >
4. >>> pow2 ( 6 )
5. 36.0
我们还注意到，内部函数 inner_func 引用了外部函数 make_pow 的自由变量 n ，这也就
意味着，当函数 make_pow 的生命周期结束之后， n 这个变量依然会保存在 inner_func
中，它被 inner_func 所引用。
1. >>> del make_pow # 删除 make_pow
2. >>> pow3 = make_pow ( 3 )
3. Traceback ( most recent call last ):
4. File “” , line 1 , in
5. NameError : name ‘make_pow’ is not defined
6. >>> pow2 ( 9 ) # pow2 仍可正常调用，自由变量 2 仍保存在 pow2 中
7. 81.0
像上面这种情况，一个函数返回了一个内部函数，该内部函数引用了外部函数的相关参数和变量，我们把该返回的内部函数称为闭包（Closure ）。
在上面的例子中， inner_func 就是一个闭包，它引用了自由变量 n 。
5.2 闭包的作用
闭包的最大特点就是引用了自由变量，即使生成闭包的环境已经释放，闭包仍然存在。
闭包在运行时可以有多个实例，即使传入的参数相同。
1. >>> pow_a = make_pow ( 2 )
2. >>> pow_b = make_pow ( 2 )
3. >>> pow_a == pow_b
4. False
利用闭包，我们还可以模拟类的实例。
这里构造一个类，用于求一个点到另一个点的距离：
1. from math import sqrt
3. class Point ( object ):
4. def __init__ ( self , x , y ):
5. self . x , self . y = x , y
7. def get_distance ( self , u , v ):
8. distance = sqrt (( self . x - u ) ** 2 + ( self . y - v ) ** 2 )
9. return distance
11. >>> pt = Point ( 7 , 2 ) # 创建一个点
12. >>> pt . get_distance ( 10 , 6 ) # 求到另一个点的距离
13. 5.0
用闭包来实现：
1. def point ( x , y ):
2. def get_distance ( u , v ):
3. return sqrt (( x - u ) ** 2 + ( y - v ) ** 2 )
5. return get_distance
7. >>> pt = point ( 7 , 2 )
8. >>> pt ( 10 , 6 )
9. 5.0
可以看到，结果是一样的，但使用闭包实现比使用类更加简洁。
5.3 常见的误区
闭包的概念很简单，但实现起来却容易出现一些误区，比如下面的例子：
1. def count ():
2. funcs = []
3. for i in [ 1 , 2 , 3 ]:
4. def f ():
5. return i
6. funcs . append ( f )
7. return funcs
在该例子中，我们在每次 for 循环中创建了一个函数，并将它存到 funcs 中。现在，调用上
面的函数，你可能认为返回结果是 1, 2, 3 ，事实上却不是：
1. >>> f1 , f2 , f3 = count ()
2. >>> f1 ()
3. 3
4. >>> f2 ()
5. 3
6. >>> f3 ()
7. 3
为什么呢？原因在于上面的函数 f 引用了变量 i ，但函数 f 并非立刻执行，当 for 循环结束时，此时变量 i 的值是 3 ， funcs 里面的函数引用的变量都是 3 ，最终结果也就全为3。
因此，我们应尽量避免在闭包中引用循环变量，或者后续会发生变化的变量。
那上面这种情况应该怎么解决呢？我们可以再创建一个函数，并将循环变量的值传给该函数，如下：
1. def count ():
2. funcs = []
3. for i in [ 1 , 2 , 3 ]:
4. def g ( param ):
5. f = lambda : param # 这里创建了一个匿名函数
6. return f
7. funcs . append ( g ( i )) # 将循环变量的值传给 g
8. return funcs
10. >>> f1 , f2 , f3 = count ()
11. >>> f1 ()
12. 1
13. >>> f2 ()
14. 2
15. >>> f3 ()
16. 3
(1)闭包是携带自由变量的函数，即使创建闭包的外部函数的生命周期结束了，闭包所引用的自由变量仍会存在。
(2)闭包在运行可以有多个实例。
(3)尽量不要在闭包中引用循环变量，或者后续会发生变化的变量。
6 装饰器
我们知道，在 Python 中，我们可以像使用变量一样使用函数：
(1)函数可以被赋值给其他变量
(2)函数可以被删除
(3)可以在函数里面再定义函数
(4)函数可以作为参数传递给另外一个函数
(5)函数可以作为另一个函数的返回
简而言之，函数就是一个对象。
6.1 对一个简单的函数进行装饰
为了更好地理解装饰器，我们先从一个简单的例子开始，假设有下面的函数：
1. def hello ():
2. return ‘hello world’
现在我们想增强 hello() 函数的功能，希望给返回加上 HTML 标签，比如 hello
world ，但是有一个要求，不改变原来 hello() 函数的定义。这里当然有很多种方法，下面
给出一种跟本文相关的方法：
1. def makeitalic ( func ):
2. def wrapped ():
3. return “” + func () + “”
4. return wrapped
在上面的代码中，我们定义了一个函数 makeitalic ，该函数有一个参数 func ，它是一个函
数；在 makeitalic 函数里面我们又定义了一个内部函数 wrapped ，并将该函数作为返回。
现在，我们就可以不改变 hello() 函数的定义，给返回加上 HTML 标签了：
1. >>> hello = makeitalic ( hello ) # 将 hello 函数传给 makeitalic
2. >>> hello ()
3. ‘hello world’
在上面，我们将 hello 函数传给 makeitalic ，再将返回赋给 hello ，此时调用
hello() 就得到了我们想要的结果。
不过要注意的是，由于我们将 makeitalic 的返回赋给了 hello ，此时 hello() 函数仍
然存在，但是它的函数名不再是 hello 了，而是 wrapped ，正是 makeitalic 返回函数的名
称，可以验证一下：
1. >>> hello . __name__
2. ‘wrapped’
对于这个小瑕疵，后文将会给出解决方法。
现在，我们梳理一下上面的例子，为了增强原函数 hello 的功能，我们定义了一个函数，它接收
原函数作为参数，并返回一个新的函数，完整的代码如下：
1. def makeitalic ( func ):
2. def wrapped ():
3. return “” + func () + “”
4. return wrapped
6. def hello ():
7. return ‘hello world’
9. hello = makeitalic ( hello )
事实上， makeitalic 就是一个装饰器（ decorator ），它『装饰』了函数 hello ，并返回一
个函数，将其赋给 hello 。
一般情况下，我们使用装饰器提供的 @ 语法糖（ Syntactic Sugar ），来简化上面的写法：
1. def makeitalic ( func ):
2. def wrapped ():
3. return “” + func () + “”
4. return wrapped
6. @makeitalic
7. def hello ():
8. ` return ‘hello world’
像上面的情况，可以动态修改函数（或类）功能的函数就是装饰器。本质上，它是一个高阶函数，以被装饰的函数（比如上面的 hello ）为参数，并返回一个包装后的函数（比如上面的 wrapped ）给被装饰函数（hello ）。
6.2 装饰器的使用形式
装饰器的一般使用形式如下：
1. @decorator
2. def func ():
3. pass
等价于下面的形式：
1. def func ():
2. pass
3. func = decorator ( func )
装饰器可以定义多个，离函数定义最近的装饰器先被调用，比如：
1. @decorator_one
2. @decorator_two
3. def func ():
4. pass
等价于：
1. def func ():
2. pass
4. func = decorator_one ( decorator_two ( func ))
装饰器还可以带参数，比如：
1. @decorator ( arg1 , arg2 )
2. def func ():
3. pass
等价于：
1. def func ():
2. pass
4. func = decorator ( arg1 , arg2 )( func )
下面我们再看一些具体的例子，以加深对它的理解。
6.3 对带参数的函数进行装饰
前面的例子中，被装饰的函数 hello() 是没有带参数的，我们看看被装饰函数带参数的情况。对
前面例子中的 hello() 函数进行改写，使其带参数，如下：
1. def makeitalic ( func ):
2. def wrapped (* args , ** kwargs ):
3. ret = func (* args , ** kwargs )
4. return ‘’ + ret + ‘’
5. return wrapped
7. @makeitalic
8. def hello ( name ):
9. return ‘hello %s’ % name
11. @makeitalic
12. def hello2 ( name1 , name2 ):
13. return ‘hello %s, %s’ % ( name1 , name2 )
由于函数 hello 带参数，因此内嵌包装函数 wrapped 也做了一点改变：
内嵌包装函数的参数传给了 func ，即被装饰函数，也就是说内嵌包装函数的参数跟被装饰函数
的参数对应，这里使用了 (*args, **kwargs) ，是为了适应可变参数。
看看使用：
1. >>> hello ( ‘python’ )
2. ‘hello python’
3. >>> hello2 ( ‘python’ , ‘java’ )
4. ‘hello python, java’
6.4 带参数的装饰器
上面的例子，我们增强了函数 hello 的功能，给它的返回加上了标签 … ，现在，我
们想改用标签 … 或
…
。是不是要像前面一样，再定义一个类似makeitalic 的装饰器呢？其实，我们可以定义一个函数，将标签作为参数，返回一个装饰器，比
如：
1. def wrap_in_tag ( tag ):
2. def decorator ( func ):
3. def wrapped (* args , ** kwargs ):
4. ret = func (* args , ** kwargs )
5. return ‘<’ + tag + ‘>’ + ret + ‘</’ + tag + ‘>’
6. return wrapped
8. return decorator
现在，我们可以根据需要生成想要的装饰器了：
1. makebold = wrap_in_tag ( ‘b’ ) # 根据 ‘b’ 返回 makebold 生成器
3. @makebold
4. def hello ( name ):
5. return ‘hello %s’ % name
7. >>> hello ( ‘world’ )
8. ‘hello world’
上面的形式也可以写得更加简洁：
1. @wrap_in_tag ( ‘b’ )
2. def hello ( name ):
3. return ‘hello %s’ % name
这就是带参数的装饰器，其实就是在装饰器外面多了一层包装，根据不同的参数返回不同的装饰器。
6.5 多个装饰器
现在，让我们来看看多个装饰器的例子，为了简单起见，下面的例子就不使用带参数的装饰器。
1. def makebold ( func ):
2. def wrapped ():
3. return ‘’ + func () + ‘’
5. return wrapped
7. def makeitalic ( func ):
8. def wrapped ():
9. return ‘’ + func () + ‘’
11. return wrapped
13. @makebold
14. @makeitalic
15. def hello ():
16. return ‘hello world’
上面定义了两个装饰器，对 hello 进行装饰，上面的最后几行代码相当于：
1. def hello ():
2. return ‘hello world’
4. hello = makebold ( makeitalic ( hello ))
调用函数 hello ：
1. >>> hello ()
2. ‘hello world’
6.6 基于类的装饰器
前面的装饰器都是一个函数，其实也可以基于类定义装饰器，看下面的例子：
1. class Bold ( object ):
2. def __init__ ( self , func ):
3. self . func = func
5. def __call__ ( self , * args , ** kwargs ):
6. return ‘’ + self . func (* args , ** kwargs ) + ‘’
8. @Bold
9. def hello ( name ):
10. return ‘hello %s’ % name
12. >>> hello ( ‘world’ )
13. ‘hello world’
可以看到，类 Bold 有两个方法：
__init__() ：它接收一个函数作为参数，也就是被装饰的函数
__call__() ：让类对象可调用，就像函数调用一样，在调用被装饰函数时被调用
还可以让类装饰器带参数：
1. class Tag ( object ):
2. def __init__ ( self , tag ):
3. self . tag = tag
5. def __call__ ( self , func ):
6. def wrapped (* args , ** kwargs ):
7. return “<{tag}>{res}</{tag}>” . format (
8. res = func (* args , ** kwargs ), tag = self . tag
9. )
10. return wrapped
12. @Tag ( ‘b’ )
13. def hello ( name ):
14. return ‘hello %s’ % name
需要注意的是，如果类装饰器有参数，则 __init__ 接收参数，而 __call__ 接收 func 。
6.7 装饰器的副作用
前面提到，使用装饰器有一个瑕疵，就是被装饰的函数，它的函数名称已经不是原来的名称了，回到最开始的例子：
1. def makeitalic ( func ):
2. def wrapped ():
3. return “” + func () + “”
4. return wrapped
6. @makeitalic
7. def hello ():
8. return ‘hello world’
函数 hello 被 makeitalic 装饰后，它的函数名称已经改变了：
1. >>> hello . __name__
2. ‘wrapped’
为了消除这样的副作用， Python 中的 functools 包提供了一个 wraps 的装饰器：
1. from functools import wraps
3. def makeitalic ( func ):
4. @wraps ( func ) # 加上 wraps 装饰器
5. def wrapped ():
6. return “” + func () + “”
7. return wrapped
9. @makeitalic
10. def hello ():
11. return ‘hello world’
13. >>> hello . __name__
14. ‘hello’
6.8 小结
(1)本质上，装饰器就是一个返回函数的高阶函数。
(2)装饰器可以动态地修改一个类或函数的功能，通过在原有的类或者函数上包裹一层修饰类或修饰函数实现。
(3)事实上，装饰器就是闭包的一种应用，但它比较特别，接收被装饰函数为参数，并返回一个函
数，赋给被装饰函数，闭包则没这种限制。
7 partial
Python 提供了一个 functools 的模块，该模块为高阶函数提供支持， partial 就是其中的一个
函数，该函数的形式如下：
1. functools . partial ( func [,* args ][, ** kwargs ])
这里先举个例子，看看它是怎么用的。
假设有如下函数：
1. def multiply ( x , y ):
2. return x * y
现在，我们想返回某个数的双倍，即：
1. >>> multiply ( 3 , y = 2 )
2. 6
3. >>> multiply ( 4 , y = 2 )
4. 8
5. >>> multiply ( 5 , y = 2 )
6. 10
上面的调用有点繁琐，每次都要传入 y=2 ，我们想到可以定义一个新的函数，把 y=2 作为默
认值，即：
1. def double ( x , y = 2 ):
2. return multiply ( x , y )
现在，我们可以这样调用了：
1. >>> double ( 3 )
2. 6
3. >>> double ( 4 )
4. 8
5. >>> double ( 5 )
6. 10
事实上，我们可以不用自己定义 double ，利用 partial ，我们可以这样：
partial 函数
1. from functools import partial
3. double = partial ( multiply , y = 2 )
partial 接收函数 multiply 作为参数，固定 multiply 的参数 y=2 ，并返回一个新
的函数给 double ，这跟我们自己定义 double 函数的效果是一样的。
所以，简单而言， partial 函数的功能就是：把一个函数的某些参数给固定住，返回一个新的函
数。
需要注意的是，我们上面是固定了 multiply 的关键字参数 y=2 ，如果直接使用：
1. double = partial ( multiply , 2 )
则 2 是赋给了 multiply 最左边的参数 x ，不信？我们可以验证一下：
1. from functools import partial
3. def subtraction ( x , y ):
4. return x - y
学好 Python 不论是就业还是做副业赚钱都不错，但要学会 Python 还是要有一个学习规划。最后大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
一、Python所有方向的学习路线
Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。
二、学习软件
工欲善其事必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。
三、全套PDF电子书
书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。
四、入门学习视频
我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。
五、实战案例
光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。
六、面试资料
我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
