python初探

　　python近两年似乎已经很热了，不了解一下怎么能行呢，似乎python最大的优点就是简洁、易懂、优雅。目前豆瓣、知乎等后台服务使用的也都是python语言。 python一般可以用于网站服务、小工具、数据分析等工作。它作为高级语言，和js一样，是解释型语言，所以运行速度上会比较慢，但是在网络服务上，相对于网速的缓慢，运行速度也就不是很大的问题了。

python环境安装

　　在windows环境下，我们可以进入这里下载安装，安装的过程中需要勾选添加到环境变量，这样，在命令行操作过程中就不会出现问题了。安装完成后，打开命令行，输入python，就进入交互模式了，输入exit()，即可退出python环境。另外，这个安装的python环境就是最为通用的python解释器cpython，之所以称为cpython，是因为这个解释器是通过c语言编写的。

简单的例子

　　我们在运行中，输入cmd进入的是命令行模式，而如果输入python，就可以进入python交互模式，因此如果我们希望运行python代码，就需要进入python交互模式，上面的图片也就是python交互模式。

　　我们还可以在进入python交互模式后，输入 print('hello world!') ，即这是python的输出字符串的语法，当然，我们也可以使用print输出多个字符串，需要使用逗号隔开，如 print('hello', 'world', 'wayne')，并且其中也是可以接受数字的，如print(200)。

　　另外，我们可以编辑一个.py后缀的python文件，然后在命令行下运行，即 python foo.py就可以执行这个foo.py文件了。

　　如上，我在sublime编辑器中新建一个foo.py，其中python语句是没有分号和花括号的，因为这样更加接近于自然语言。然后在命令行中运行:

　　这样，一个简单的python程序就出来了。

输入输出

　　python中的输入输出也是非常简单的。

　　输出就是使用print，可以接受多个参数，参数的类型可以是数字也可是字符串，当然字符串中可以有\t和\n等。

　　输入当然也是交互中必不可少的，为name()，这个在执行之后，会提示用户输入，name()函数可以接受一个字符串作为参数，如name('请输入你的名字：')，举例如下：

name = input('请输入你的名字:')
print('你好，', name)

python基础知识

　 python作为计算机语言，那么语言就必须要计算机理解，必须有一定的规则，而不是像自然语言很随意。python的语法是比较简单的，采用的时特有的缩进的方式，并且没有像js那样分号作为语句的结束，且语句在使用 : （冒号）结尾时，缩进的语句视为代码块，缩进没有特定的要求，但是一般以4个空格为准，且python是大小写敏感的。 python中使用#作为注释的标志。且python中不需要声明变量，直接使用就可以了。如下所示：

num = input('请输入一个数字')
if int(num) > 0:print('您输入的数字大于0')
elif int(num) < 0:print('您输入的数字小于0')
else:print('您输入的数字等于0')

我们可以看到python中的else if需要写成elif，否则会报错，这样也正是python简洁的体现，而通过input()函数输入的是一个字符串，在直接判断与0的大小时会出错，所以我们可以使用int()来讲字符串强制转化为数字，就可以进一步的比较了。如下：

python中的数据类型和其他语言都是大同小异的，包括整数、浮点数、字符串、布尔值以及运算。其中布尔值有些许不同，如True表示真，而False表示假，第一个字母需要大写，另外，我们可以使用 and、 or、 not 来表示布尔值的与、或、非运算，这使得python更加接近自然语言。python中使用None表示空值。它的变量同样是大小写英文、数字和_组合，且不能使用数字作为开头。 python是动态语言，因为他的变量类型和js一样是可以变动的，而不像java。另外，python中的除法有两种，一种是普通的 / ，这种方法不管除数和被除数为整数或者浮点数，得到的结果都是浮点数；而 // 这种除法得到的结果总是整数。同样，python使用 % 作为求余的操作符。

python字符串和编码

　　对于字符串而言，最为复杂的就是编码问题了，因为计算机只能处理0/1数字，所以要处理文本，就必须先把文本转换为数字才能处理。

　　1个字节是8个bit，所以一个字节能表示的最大的整数是255，也就是说用一个字节编码的方式可以最多表示255种字符。而最早是美国人发明了计算机，他们使用的语言只有a-zA-Z和其他字符一共127个，即ASCII编码。但对于十万个汉字的编码，显然ASCII编码是做不到，而两个字节可以表示6万多种字符，所以，中文的编码至少需要2个字节，于是中国制定了GB2312编码。 但世界上有上百种文字，日本要把日文编到Shift_jis中，韩国把韩文编到Euc-kr中，显然，这样就没有了统一的标准，而使得有多种文字编码的文本中，很可能出现乱码的情况。

　　因此，Unicode编码应运而生，即union code，统一的编码，这种编码包含了各国文字，使得文本可以通用，而不必担心出现乱码的情况，Unicode编码一般是两个字节，但两个字节只能表示6万多字符，所以有时也会有四个字节的情况，但对于常用的文字，一般都是两个字节。但如果一直使用Unicode编码，问题是如果通篇英文，Unicode编码会比ASCII编码多出一倍的存储空间，这是非常浪费的，于是，又出现了 UTF-8编码，这种编码把一个unicode字符根据不同的数字大小编为1 - 6个字节，常用的英文字母还是1个字节（可以将ASCII编码看做UTF-8编码的一部分），而汉字通常是3个字节，所以如果传输中包含了大量的英文字符，使用UTF-8编码会更加节省空间。　　

　　实际上，在计算机内存中，统一使用Unicode编码，当需要保存到硬盘或者传输的时候，就转换成UTF-8编码，如浏览网页的时候，服务器会把动态生成的Unicode内容转换成UTF-8再传输到浏览器。这样我们也就理解HTML文件中 <meta charset="UTF-8"/>的含义了。

　　而python中字符串也是Unicode编码的，即它支持多种语言，而不会出现乱码。对于单个字符的编码，python提供了ord()函数获取字符的整数表示（Unicode编码的整数表示），chr()函数把编码转换为对应的字符。

　　而如果我们知道字符的整数编码，还可以用十六进制来写str，如

>>> '\u4e2d\u6587'
'中文'

　　其中，\u这个转义字符表示Unicode编码，而4e2d是十六进制的编码，即中这个汉子用了两个字节来表示，同样文也用了两个字节来表示。

　　另外，Python中提供了encode()函数和decode()函数来进行编码和解码，len()函数来返回字符长度。

　　在python中，也经常需要格式化，和c语言是非常类似的，%s为字符串，%d为整数，%f为浮点数，%x为十六进制数，并且如果在表示中有%我们需要进行转义%%，另外，如果不知道该用哪个占位符，统一使用%s就可以了。format()函数也是同样的表达方式，但相对于前者还是稍显复杂，如下所示：

使用list和tuple

　　在c++中有List和tuple这两种数据类型，而在python中同样也有。 list比tuple有更多的操作方法，但是tupple一旦定义不能被改变，因而更加安全，下面做简单介绍。

　　如上所示，我们可以直接定义rel = ['wayne', 'hedy', 'baby']这个list，使用len()函数可以获取这个list的长度，使用rel[0]这种下标可以获取其中的元素，通过append()可以将元素添加到末尾，通过pop()可以弹出（删除）最后一个元素，我们还可以通过insert()将元素插入到指定位置，使用pop(num)将指定位置的元素删除，并且使用 rel[num] = str的方式直接替换list中的某个元素。因此，list数据类型还是非常方便，操作起来更为简单、强大。

　　tupple和list非常类似，只是在定义的时候使用的时()而非[]，并且最为本质的区别在于tupple一旦定义只能访问不能修改，当然也就没有append、insert、pop这些方法了，优点就是更安全，如果可以使用tupple就尽量不要使用list。

　　可以看到，我们定义了rel之后，只能进行访问，而在试图修改时发生了错误。

循环

　　python中有两种循环。一种是使用for...in循环，另外一种便是while循环。　

rel = ['wayne', 'hedy', 'baby']
for name in rel:print(name, '\n')

　　以上是使用for...in循环rel这个list，注意，以为for下一行缩进，所以for语句后有 : （冒号）。

　　另外，python中提供了range函数，如list(range(50)) 可以生成一个0到49的list，而不需要我们手写了。同样，for...in也可以使用range，如下：

max = int(input('请输入一个正整数：'))
sum = 0
for a in range(max + 1):sum = sum + a
print('1到%d' % max, '的和为：',sum )

　　运行结果如下所示：

　　而while循环和其他语言的循环也是类似的，如下所示：

import time
n = int(input('请输入一个正整数：'))
while n > 0:print(n, 's\n')time.sleep(1)n = n - 1
print('over!')

这里我们在python文件中直接引入了time模块，通过time模块的sleep函数使得程序在运行到这一语句时暂停1s中而继续运行。　

　　同样的，在python中也可以正常使用break和continue关键词。

dict和set

　　在c++中提供了map这样的数据结构，这种数据结构是含有多个k-v对，具有一一映射的特点，而在python中也提供了同样的数据结构，只是名称为dict，即dictionary字典，使用起来非常简单。且list使用的时[]，tuple使用的时()，这里的dict使用的是{}，如下：

　　如上所示，我们使用{}来定义这个dict，并且可以使用d[key]的方式获取到它的值，另外dict提供了get方法来查找相应的value，当然，如果不存在，则什么也不会返回。且可以通过d[key]的方式来添加映射。通过pop()函数来删除其中的某个k-v对。注意：dict中的key是不能重复的。

　　那么set是怎么样定义的呢？set和dict非常类似，但是set中只有key而没有value，相同点在于key都是不能重复的，如果重复，则也会自动过滤， set有add方法添加key，通过remove方法删除， set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作。如下所示：

　　如上所示：我们可以看到，set()函数中实际上就是一个list，通过add添加key，通过remove删除key，通过s1 = s来赋值，且两个set之间可以进行并集和交集的运算。

　　另外，我们可以看到，这里s3本来是有重复数字的，但在建立后生成时，重复数字会自动被删除，这便是set的一大特点。

python函数

　　python中内置了很多函数，比如之前的chr()等，这些函数是可以直接调用的，文档中查看更多内置函数。https://docs.python.org/3/library/functions.html#abs

　　比如abs即求绝对值的函数、max函数返回多个参数中最大的一个、min函数等等。更多示范可以看另外一篇文章。

python切片

　　即和js中的slice方法是类似的，但是python中是没有slice的，而是使用了更为简单的方式，如下：

>>> L = [0,1,2,3,4,5,6,7,8,9,10]
>>> L[0:3]
[0, 1, 2]
>>> L[:3]
[0, 1, 2]
>>> L[2:4]
[2, 3]
>>> L[-2:]
[9, 10]
>>> L = list(range(20))
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> L[0::2]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> L[::2]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
>>> "wayne-zhu"[0:5]
'wayne'
>>> t = (1, 56, 74, 85, 9)
>>> t[0:3]
(1, 56, 74)

　　即对于list而言，指定开始和结束的后一个位置，即可进行切片；

如果是从0开始，则数字0是可以省略的；

如果是负数，就是从倒数第几个开始，最后一个是-1；

我们还可以指定每隔几个数取出一个数出来；

字符串也可以看成一种list，也是可以用类似的方法的；

　　tupple和list一样，只是tupple不可变，但也是可以使用这样的方法。

　　下面是使用python定义的trim函数，实现方式如下：

def trim(str):old = stri = 0while True:if str[i] == ' ':str = str[1:]else:breakj = len(str) - 1while True:if str[j] == ' ':str = str[0:j]j = len(str) - 1else:breakprint(old,'trim之后为：',str,'trim之后的字符长度为', len(str))trim('   wayne       ')

　　我们首先将str保存起来，然后对字符串的前半部分进行处理 - 如果第一个字符是空格就slice；对于字符串的后半部分做出同样的处理。结果如下：

C:\Users\Administrator\Desktop>python foo.pywayne        trim之后为： wayne trim之后的字符长度为 5

python迭代

　　在js、c、c++等编程语言中，for循环都是大同小异的，如for(int i = 0; i < 10; i++)，而在python中，for循环变得更加抽象了，如下所示：

d = {'wayne': 22, 'hedy': 18, 'baby': 0}
print('key:')
for key in d:print(key)print('\nvalue')for value in d.values():print(value)print('\nkey and value')
for k,v in d.items():print(k, v)

　　结果如下：

key:
wayne
hedy
babyvalue
22
18
0key and value
wayne 22
hedy 18
baby 0

　　另外，字符串也是可迭代对象。

print('\n 字符串的迭代：')
s = 'wayne-zhu'
for ch in s:print(ch)

　　这样，可以依次将字符打印出来。

　　那么我们如何判断一个对象是否为可迭代对象呢？可以通过collections模块的Iterable类型判断：

from collections import Iterable
print(isinstance('wayne', Iterable)) #True
print(isinstance([1, 2, 3], Iterable)) #True
print(isinstance(888, Iterable)) #False

　　如上所示，我们通过isinstance就可以判断了。这里其实是判断'wayne'、[1, 2, 3]、888是否是Iterable这个类的实例。 该函数返回一个布尔值，True或者False。

　　另外，list是没有下标的，我们怎么实现呢？可以使用enumerate()函数，如下所示：

L = [666, 888, 520, 521, 1314]
for k,v in enumerate(L):print(k, v)

　　最终结果如下所示：

　　可以看到，这样我们就可以获得下标了。

练习：使用迭代的方法获得一个list中的最大值和最小值，并返回这个list的tupple：

L = [666, 888, 520, 521, 1314]
max = L[0]
min = L[0]
for k,v in enumerate(L):if L[k] > max:max = L[k]if L[k] < min:min = L[k]print(max, min)
print(tuple(L))

结果如下；

1314 520
(666, 888, 520, 521, 1314)

python列表生成式

　　生成1到10的列表，使用下面的语法：

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

　　如果要生成[1 * 1, ... 10 * 10]的列表呢？

>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

　　上面这种语法是常见的，即直接将迭代式子写在[]中，前半部分是我们所需要的表达式。

　　另外，对于字符串而言，我们通常需要生成某个字符的全排列，可以这样：　　

>>> [m + n for m in 'xyz' for n in 'xyz']
['xx', 'xy', 'xz', 'yx', 'yy', 'yz', 'zx', 'zy', 'zz']

　　上面的式子就生成了xyz的全排列，xx、xy、xz、yx、yy、yz、zx、zy、zz，当然我们还可以生成不同字符串之间的全排列，这是非常有用的。

　　下面的代码还可以将list中的所有字母编程小写：

>>> L = ['WAYNE', 'HEDY', 'BABY']
>>> [s.lower() for s in L]
['wayne', 'hedy', 'baby']

　　其中 lower() 函数是将字符串转化为小写，而upper()函数可以将字符串转化为大写，如下所示：

>>> wayne = ['wayne', 'hedy', 'baby']
>>> [s.upper() for s in wayne]
['WAYNE', 'HEDY', 'BABY']

　　注意：上面的s.upper()也可以写成 str.upper(s)， lower同理。

　　另外，如果我们的L为['Wayne', 'Hedy', 18, None]如果直接使用列表生成式会因为18不是字符串而出错：

>>> L = ['Wayne', 'Hedy', 18, None]
>>> [str.lower(i) for i in L]
Traceback (most recent call last):File "<stdin>", line 1, in <module>File "<stdin>", line 1, in <listcomp>
TypeError: descriptor 'lower' requires a 'str' object but received a 'int'

　　我们试着使用if语句以及isinstance来修改：

>>> [str.lower(i) for i in L if isinstance(i, str)]
['wayne', 'hedy']

　　即在这个列表生成式中直接加入if语句，然后使用isinstance判断i是否是str(字符串)类型即可。

python生成器

　创建一个列表就会打印出所有的元素，而如果这个列表的元素很多而我们仅仅需要访问其中的前几个元素，那么生成整个列表就会造成浪费。而如果列表元素可以按照某种方法算法推算出来，那么我们是否可以在循环的过程中不断地推算出后续的元素呢？这样就不必创建完整的list，而节省了大量的空间。在python中一边循环一边计算后续元素的机制，就称为生成器。

　　比如，我们创建了一个1到100的list，如下：

>>> list(range(1, 100))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]

　　但如果我们只需要1到100的前几个元素，那么后续元素占用的内存就造成了浪费。而生成器（generator）是下面这样的：

>>> g = (x for x in range(1, 100))
>>> g
<generator object <genexpr> at 0x02C41E70>

　　如果我们希望访问其元素，可以使用next()进行访问，next函数接受一个参数，即这个生成器g，如下所示：

>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
4
>>> next(g)
5

　　如上所示，每调用一次next()函数，就会返回生成器的下一个元素，生成之后，才会给这个元素分配内存，这样便大大节省了内存空间，即做到按需分配。

　　又比如下面的生成器：

>>> g = (x for x in range(1, 5))
>>> g
<generator object <genexpr> at 0x02C6F0F0>
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
4
>>> next(g)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
StopIteration

　　可以看到，这里我们定义了元素从1到4的生成器，打印g，显示g为一个generator，然后调用next()函数，返回generator的元素，每调用一次，返回下一个元素，但是当最后一个元素4已经打印出来后，再调用next()，就会报错：即stopIteration，停止遍历。

　　当然，更多情况下，我们还可以使用for来遍历生成器，因为生成器是可遍历的，如下：

g = (x * x for x in range(1, 5))
for n in g:print(n)

　　打印出的结果如下所示：

C:\Users\Administrator\Desktop>python foo.py
1
4
9
16

　　上面，我们都是直接使用()加表达式生成了一个生成器，但如果推算较为复杂的情况下，我们还可以使用函数的方式。首先，我们可以看到如果斐波那契数列的函数生成：

def fib(max):n, a, b = 0, 0, 1while (n < max):print(b)a, b = b, a + bn = n + 1return 'done'fib(5) # 1 1 2 3 5

这里需要注意：python中定义变量更为简洁，即这里的n, a, b = 0, 0, 1简洁的一句代码便定义了三个变量
a, b = b, a + b的定义也是非常简洁，这里没有使用中间变量保存a，而是使用了tupple的数据结构，即t = (b, a + b)、 a = t[0]、 b = t[1]。

　　而如果我们这里将 print(b) 修改为 yield(b)，就是一个生成器了。对于生成器来说，每次yield的时候，都会暂停，必须使用next()才能继续执行下面的程序。所以就成了生成器了。而对于生成器来说，我们使用for..in来调用会更加方便一些：

def fib(max):n, a, b = 0, 0, 1while (n < max):yield(b)a, b = b, a + bn = n + 1return 'done'g = fib(5) # 1 1 2 3 5for x in g:print(x)

　　如上所示：我们可以看到这时的fib就是一个生成器了，且可以使用for...in遍历。

python迭代器

　　之前我们提到过："abc"、[]等都是Iterable（可迭代的），但是他们并不是迭代器，如下所示：

>>> from collections import Iterable
>>> isinstance([], Iterable)
True
>>> isinstance({}, Iterable)
True
>>> isinstance('abc', Iterable)
True
>>> isinstance((x for x in range(1, 10)), Iterable)
True
>>> isinstance(628, Iterable)
False

　　我们可以看到：[]、{}、'abc'、(x for x in range(1, 10))都是可迭代的，只有628这个数字肯定不是的。如果换做迭代器呢？

from collections import Iterator # 注意：这里import要换做Iterator
print(isinstance({}, Iterator)) #False
print(isinstance('abc', Iterator)) #False
print(isinstance((x for x in range(1, 10)), Iterator)) #True
print(isinstance(628, Iterator)) #False

　　这里，我们可以看到，只有（x for x in range(1, 10)）是迭代器，其他都不是迭代器，这是为什么呢？

>>> g = (x for x in range(1, 10))
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
4

　　我们可以看到，(x for x in range(1, 10))这个表达式可以调用next函数，知道最后元素迭代完成，会报错：stopIteration。

　　而'abc'呢？如下所示：

>>> g = 'abc'
>>> g
'abc'
>>> next(g)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'str' object is not an iterator

　　如上所示：使用'abc'的next函数时，会直接报错：'str' object is not an iterator。即字符串不是一个迭代器。对于list、disc也同样如此，所以这里只有tupple才是Iterator。

>>> g = {'wayne':22, 'hedy': 18}
>>> g
{'wayne': 22, 'hedy': 18}
>>> next(g)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'dict' object is not an iterator

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

　　　但是，我们是可以将非Iterator强制转换为Iterator的。使用iter()函数即可。但前提是它们必须是Iterable，对于628这样的not Iterable的类型，使用iter()也是无济于事的。如下所示：

>>> s = 'abc'
>>> s
'abc'
>>> i = iter(s)
>>> i
<str_iterator object at 0x039F4670>
>>> next(i)
'a'
>>> next(i)
'b'
>>> next(i)
'c'

　　　628不是Iterable，如下：

>>> n = 628
>>> i = iter(n)
Traceback (most recent call last):File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

　　可以看到，对于int类型的628，如果使用iter，也是会报错的 --- 'int' object is not iterable

　　那为什么list不是Iterator呢？这是因为Iterator是惰性的，并没有一次性获取到所有的数据，是无限制的，而list是一开始就存储了数据。

高阶函数

　　即函数中接受函数作为参数的函数就是高阶函数。如map、filter等。又如sorted函数，如下：

>>> sorted([35, -56, 85, 69])
[-56, 35, 69, 85]
# 如上，这里没有接受函数作为参数，只是按照从小到大的排序
>>> sorted([35, -56, 85, 69], key=abs)
[35, -56, 69, 85]
# 这里我们接受了abs函数作为第二个参数，即按照其绝对值大小进行排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'])
['Credit', 'Zoo', 'about', 'bob']
#这里我们直接对字符串进行排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower)
['about', 'bob', 'Credit', 'Zoo']
#这里我们将所有的字符串按照转化为小写字母之后进行排序
>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
['Zoo', 'Credit', 'bob', 'about']
#如果我们希望反向，只需要再添加一个参数 -- reverse = True

　在python中，也是存在匿名函数的概念的，如下：

>>> f = lambda x: x * x
>>> f(5)
25

　　如上所示：等式右边的就是一个匿名函数，而 lambda 关键词就表示在声明一个匿名函数，冒号之前的x表示接受的参数，之后表示返回的值。

python装饰器

　　如下所示：定义一个now函数，因为函数是一个对象，所以可以赋值给f（另外一个变量），然后我们再调用这个函数即可。

>>> def now():
...     print('20180324')
...
>>> f = now
>>> f()
20180324

　　在python中，我们可以调用now或者f的__name__属性，以获取到该函数的函数名：如下：

>>> now.__name__
'now'
>>> f.__name__
'now'

　　那什么是装饰器呢？比如，我们希望函数调用前后自动打印日志，但是又不希望修改now()函数的定义，这种在代码运行期间动态增加功能的方式，称之为装饰器。并需要用到@的Python语法。

　　下面我就定义一个装饰器函数用于打印日志：

def log(func):def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper

　　这个装饰器函数就是一个高阶函数（接受一个函数作为参数），然后定义了一个wrapper函数返回fun()执行后的结果。然后我们将Log置于函数的定义处：

def log(func):def wrapper(*args, **kw):print('call %s():' % func.__name__)return func(*args, **kw)return wrapper@log
def now():print('20180324')now()

　　我们执行之后，得到如下结果：

call now():
20180324

　　至于上面的格式，即将@log放在了now函数的定义之前，相当于在定义之后执行了函数 now = log(now)，即把这个now函数从新进行了包装、修饰，即为装饰器函数。因此，我们写成下面的方式也是可以的：

def log(func):def wrapper():print('call %s():' % func.__name__)return func()return wrapper@log
def now():print('20180324')now()

　　之前添加了的一些参数是为了更多的使用扩展性。即now()函数执行之后，即调用了这个装饰器函数@log，返回了wrapper函数，最后我们调用now()，就执行了这个wrapper函数，并返回结果。

　　这里，我们可以将@log解释为如下的执行方式:

def log(func):def wrapper():print('call %s' % func.__name__)return func()return wrapperdef now():print('20180324')now = log(now) # 这样，会fanhuiwrapper函数，然后调用now，就是执行了wrapper函数，首先打印了内容，再执行真正的now函数。now()

　　上面是最简单的方式，而如果这个装饰器自身需要接受参数，那么如果使用上面的这种方式就无法满足了，我们必须再包裹一层函数，如下所示：

def log(text):def decorator(func):def wrapper():print('call %s %s' % (text, func.__name__))return func()return wrapperreturn decorator  @log('extro')
def now():print('20180324')now()

　　思路非常明确，即包含了一层decorator函数，我们将text传给装饰器，实际上，@log('extro')的另外一种真是的写法如下：

def log(text):def decorator(func):def wrapper():print('call %s %s' % (text, func.__name__))return func()return wrapperreturn decorator  def now():print('20180324')now = log('extor')(now)now()

　　最终的结果如下：

call extor now
20180324

　　但这里还是有问题的，当我们在程序的最后加上 print(now.__name__)的时候，我们可以发现最终输出的时 wrapper 而不是 now，这不是我们希望看到的，而我们修改之后最终的结果如下：

import functoolsdef log(text):def decorator(func):@functools.wraps(func)def wrapper():print('call %s %s' % (text, func.__name__))return func()return wrapperreturn decorator  def now():print('20180324')now = log('extor')(now)now()print(now.__name__)

python偏函数

　　偏函数还是很好理解的，我们从一个简单的例子说起。

　　比如我们可以使用int('1000')将字符串'1000'转化为数字，这个转化过程默认是十进制的。而如果我们希望转化为2进制的，我们可以这样调用：int('1000', base=2)或者是int('1000', 2)。但是如果我们需要大量的转化为二进制数字的调用，每次都int('1000', 2)难免比较麻烦，所以我们可以封装为一个函数再调用，如下：

def int2(str):return int(str, base=2)print(int2('100')) #4
print(int2('10')) #2
print(int2('1')) #1

　　如上所示，这样，我们就可以很轻松的进行转化了。但python中的functools模块本身有这个作用，如下：

import functools
int2 = functools.partial(int, base=2)print(int2('100')) #4
print(int2('10')) #2
print(int2('1')) #1

　　即这里我们使用了functools.partial函数，这就是偏函数，即把一个函数的某些参数给固定住（也就是设置为默认值），返回一个新的函数，调用这个函数会更加简答。而我们也可以继续个性化，如下：

import functools
int2 = functools.partial(int, base=2)print(int2('100',base=10)) #100
print(int2('10')) #2
print(int2('1')) #1

　　如上，可以看出来，这个和我们上面自己定义的int2是相同的，总之，偏函数可以固定住某些参数，使我们的操作更加简单。

python模块

　　和JavaScript是类似的，大多数编程语言都是要进行模块化开发的，因为当工程越来越复杂的时候，不可能始终使用一个文件，而是根据程序块的不同作用分配到模块中，这样，有利于开发的高效性，另外，同一个模块还可以在多处使用，这样有利于提高程序的重用性，python也不例外。　　

　　python中，一个.py文件就可以看做一个python模块，模块很好地解决了变量命名冲突的问题，并且通过模块，但当模块多时，也不可避免出现重名，在python中也就有了包的概念，如一个mymodule包，下面有util.py模块、anto.py模块，并且一定还有一个__init__.py模块，如果没有，Python将不认为mymodule是一个包，通过这个包，我们的模块名称更具辨识性，如util.py模块又称为mymodule.util模块等等。

　　使用模块我们很清楚，直接import 即可，但是如果自定义一个自己的模块呢？如下所示（该文件名为hello.py）：

'my first module'__author__ = 'Wayne Zhu'import sysdef test():args = sys.argvif len(args) == 1:print('hello world!')elif len(args) == 2:print('hello %s' % args[1])else:print('Too many arguments!')if __name__ == '__main__':test()

　　Ok！这就是一个标准的模块了，其中'my first module'是这个py文件的第一个字符串，默认为该文件的说明性注释；而__author__ = 'Wayne Zhu'中的__author__是专有变量，是声明这个文件的作者，接下来我们引入了sys模块，通过这个模块我们可以获得用户在命令行输入的参数；最后我们判断__name__是否为__main__，如果是执行当前文件，则是，作为入口文件，当然是main，如果是被其他Python文件调用，则不是。

　　其中，sys的argv参数是命令行的参数，如python hello，则argv是一个list，且数量至少为1，这里就是['hello']，而如果用户执行时是 python hello wayne-zhu，则sys.argv的元素个数为2，即['hello', 'wayne-zhu']。

　　该模块如果被直接调用，最终的结果如下：

C:\Users\Administrator\Desktop>python hello.py
hello world!C:\Users\Administrator\Desktop>python hello.py wayne-zhu
hello wayne-zhuC:\Users\Administrator\Desktop>python hello.py wayne hedy
Too many arguments!

　　而如果我们是在python交互环境中引入hello模块，则不会有输出，如下：

>>> import hello
>>> hello.test()
hello world!

　　但是我们可以直接通过hello调用test函数。

python变量

　　这里主要说的还是变量的可访问性。

公开变量，abc/foo等，这些变量是公开的，允许被模块内外访问的。
模块内变量/私有变量，_abc、_foo等，即简单的通过_来确定，但实际上语法并没有限制，只是方便程序员观察使用。
特殊变量，__name__、__author__等，这些变量和公开变量并没有什么区别，只是他们有特殊的用途，如__author__表示当前模块的作者名; __name__和'__main__'判断是否相等来判断是直接执行还是间接调用。

def _private_1(name):return 'Hello, %s' % namedef _private_2(name):return 'Hi, %s' % namedef greeting(name):if len(name) > 3:return _private_1(name)else:return _private_2(name)

　　比如上面的例子中，_private_1和_private2是模块内使用的，而greeting是暴露出去的，可以被其他的模块使用。

　　hello.py如下：

'my first module'__author__ = 'Wayne Zhu'import sysdef test():args = sys.argvif len(args) == 1:print('hello world!')elif len(args) == 2:print('hello %s' % args[1])else:print('Too many arguments!')def speak(str='great!'):print(str)if __name__ == '__main__':test()

View Code

　　foo.py如下：

import hello
hello.test()
hello.speak('I am handsome')

　　当我们执行foo.py时，最终的结果如下：

hello world!
I am handsome

　　可见，我们成功的在foo.py中引用了hello模块，并使用了hello模块暴露的speak函数和test函数，但是根据hello模块test编写形式而言，test主要是为了作模块内测试的，并非暴露给其他模块使用。但语法上并没有任何问题。

安装第三方模块

　　我们在命令行中输入pip，如果正常，则说明可以通过pip安装第三方模块，这个和前端中的npm是类似的，并且，一般的开发者如果要提供自己的模块，需要到pypi.python.org中注册，和前端需要到npm.org中注册时一样的，比如我们要安装该库的名称是 Pillow，那么安装Pillow的命令就是：

pip install Pillow

　　如下所示：

C:\Users\Administrator\Desktop>pip install Pillow
Collecting PillowDownloading Pillow-5.0.0-cp36-cp36m-win32.whl (1.4MB)100% |████████████████████████████████| 1.4MB 655kB/s
Installing collected packages: Pillow
Successfully installed Pillow-5.0.0
You are using pip version 9.0.1, however version 9.0.3 is available.
You should consider upgrading via the 'python -m pip install --upgrade pip' command.

　　但是，这里下载的位置在C:\Users\Administrator\AppData\Local\Programs\Python\Python36-32\Lib\site-packages，所以，如果我们希望自己新建一个py文件可以import Pillow，就必须要将Pillow这个文件夹放在和当前py文件的同级目录下，否则就引入不了。

　　同样的，Flask这个web框架就是python框架，安装如下：

pip install flask

　　然后，我们再新建下面这个文件：

from flask import Flaskapp = Flask(__name__)@app.route('/')
def hello_world():return 'Hello Flask!'if __name__ == '__main__':app.run()

　　然后在命令行中执行这个文件：

C:\Users\Administrator\Desktop>python foo.py* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

　　于是我们就可以看到浏览器如下：

　　即通过这个Flask库，我们就自己快速搭建了一个服务器。但是我们可以发现一个问题，就是每次在我们修改文件内容时，比如返回 Hello Wayne!，然后我们去刷新浏览器，但显示内容并没有刷新，这是因为我们没有开启DEBUG模式，如果要开启，我们需要在环境变量中添加 FLASK_DEBUG, 值为1，如下：

　　这样，我们在运行该文件时，内容时这样的：

C:\Users\Administrator\Desktop>python foo.py* Restarting with stat* Debugger is active!* Debugger PIN: 109-984-470* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

　　即调试模式开启，我们就可以进行调试了。且每次我们修改文件并保存后，服务器就会重启，然后我们刷新浏览器，内容就会发生改变了！这方面的使用还是比node更加方便一些。

　　另外还有很多有用的模块，如果我们都这样下载，未免太慢，所以推荐使用Anaconda，这个平台一旦下载就意味着下载了数十个库文件，这样是非常有用的，我们可以在这里下载。　　

　　安装完成之后，输入python，我们就可以看到Anaconda的相关信息了。然后，对于一些常见的模块我们就不需要再自己下载，而是直接使用即可。但有些情况下，安装之后输入python还是没用，这时我们可以将anaconda的安装路径加入到path中即可，如：

　　注意：现在，不下载也是可以的，最多全部下载一遍，不适用Anaconada也是一样的，不必过分纠结。

　　另外，之前我们说过：每次install一个模块之后，可以通过everything这个工具找到该文件，然后将当前python文件和库文件放在同级目录下才可以使用，但这样比较麻烦，我们可以将存放install的库的路径加入到sys模块的path变量中，这样我们就不用每次都把下载到的文件再手动放在一起了。

 import sys
>>> sys.path
['', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\python36.zip', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\DLLs', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\lib', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32', 'C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\lib\\site-packages']
>>> sys.path.append('C:\\Users\\Administrator\\AppData\\Local\\Programs\\Python\\Python36-32\\Lib\\site-packages')