Python

预备知识：
空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。此外，
Python还提供了列表、字典等多种数据类型，还允许创建自定义数据类型。Python的注释以 # 开头，后面的文字直到行
尾都算注释# 这一行全部都是注释...print 'hello' # 这也是注释   会输出hello如果一个字符串包含很多需要转义
的字符，对每一个字符都进行转义会很麻烦。为了避免这种情况，我们可以在字符串前面加个前缀 r ，表示这是一个 raw 字符串，里面的字符就不需要转义了。例如：r'\(~_~)/ \(~_~)/'
但是r'...'表示法不能表示多行字符串，也不能表示包含'和 "的字符串（为什么？）
如果要表示多行字符串，可以用'''...'''表示：
'''Line 1
Line 2
Line 3'''
上面这个字符串的表示方法和下面的是完全一样的：
'Line 1\nLine 2\nLine 3'
还可以在多行字符串前面添加 r ，把这个多行字符串也变成一个raw字符串：
r'''Python is created by "Guido".
It is free and easy to learn.
Let's start learn Python in imooc!'''
----------------------------------------------------------------------------------------------------------------------------------------------------------
a = True
print a and 'a=T' or 'a=F'
计算结果不是布尔类型，而是字符串 'a=T'，这是为什么呢？因为Python把0、空字符串''和None看成 False，其他数
值和非空字符串都看成 True，所以：True and 'a=T' 计算结果是 'a=T'
继续计算 'a=T' or 'a=F' 计算结果还是 'a=T'要解释上述结果，又涉及到 and 和 or 运算的一条重要法则：短路计
算。1. 在计算 a and b 时，如果 a 是 False，则根据与运算法则，整个结果必定为 False，因此返回 a；如果 a 是 True，则整个计算结果必定取决与 b，因此返回 b。2. 在计算 a or b 时，如果 a 是 True，则根据或运算法则，整个计算结果必定为 True，因此返回 a；如果 a 是 False，则整个计算结果必定取决于 b，因此返回 b。所以Python解释器在做布尔运算时，只要能提前确定计算结果，它就不会往后算了，直接返回结果。
Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。list是数学意义上的有序集合，也就是说，list中的元素是按照顺序排列的。构造list非常简单，按照上面的代码，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。通常，我们会把list赋值给一个变量，这样，就可以通过变量来引用
list：classmates = ['Michael', 'Bob', 'Tracy']
print classmates
由于Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种：
L = ['Michael', 100, True]
索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索引是1，以此类推。我们可以用 -1 这个索引来表示最后一个元素，类似的，倒数第二用 -2 表示，倒数第三用 -3 表示，倒数第四用 -4 表示
append()总是把新的元素添加到 list 的尾部。list的 insert()方法，它接受两个参数，第一个参数是索引号，第二个参数是待添加的新元素
pop()方法总是删掉list的最后一个元素，并且它还返回这个元素，所以我们执行 L.pop() 后，会打印出这个元素。可以用 pop(2)把索引为2的元素删除
替换： L = ['Adam', 'Lisa', 'Bart']   L[2] = 'Paul'

tuple是另一种有序的列表，中文翻译为“ 元组 ”。tuple 和 list 非常类似，但是，tuple一旦创建完毕，就不能修

改了。创建tuple和创建list唯一不同之处是用( )替代了[ ]。获取 tuple 元素的方式和 list 是一模一样的
t = (1)  print t结果为1，因为()既可以表示tuple，又可以作为括号表示运算时的优先级，结果 (1) 被Python解释

器计算出结果 1，导致我们得到的不是tuple，而是整数 1。
正是因为用()定义单元素的tuple有歧义，所以 Python 规定，单元素 tuple 要多加一个逗号“,”，这样就避免了歧义：t = (1,)   print t 结果为(1,)

tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。

即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
注意: Python代码的缩进规则。具有相同缩进的代码被视为代码块，上面的3，4行 print 语句就构成一个代码块（但不包括第5行的print）。如果 if 语句判断为 True，就会执行这个代码块。

缩进请严格按照Python的习惯写法：4个空格，不要使用Tab，更不要混合Tab和空格，否则很容易造成因为缩进引起的语法错误。

注意: if 语句后接表达式，然后用:表示代码块开始。

如果你在Python交互环境下敲代码，还要特别留意缩进，并且退出缩进需要多敲一行回车 练习：
score=55
if score >= 60:
    score=bytes(score)
    print 'passed:'+score
else:
    print 'nopass'
age = 8
if age >= 6:
    print 'teenager'
elif age >= 18:
    print 'adult'
else:
    print 'kid'
Python的 for 循环就可以依次把list或tuple的每个元素迭代出来：L = ['Adam', 'Lisa', 'Bart']
for name in L:
    print name
注意:  name 这个变量是在 for 循环中定义的，意思是，依次取出list中的每一个元素，并把元素赋值给 name，然后执行for循环体，这样，遍历一个list或tuple就非常容易了
花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。由于

dict也是集合，len() 函数可以计算任意集合的大小：

可以简单地使用 d[key] 的形式来查找对应的 value
通过 key 访问 dict 的value，如果key不存在，会直接报错：KeyError。要避免 KeyError 发生，有两个办法：一是先判断一下 key 是否存在，用 in 操作符：

if 'Paul' in d:
    print d['Paul']
二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None
dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。

不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。由于dict是按 key 查找，所以，在一个dict中，key不能重复。

dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样
dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}要把新同学'Paul'的成绩 72 加进去，用赋值语句 d['Paul'] = 72如果 key 已经存在，则赋值会用新的 value 替

换掉原来的 value
练习：
d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
for key in d:
    print key
    print d[key]
    print d.get(key)
set 持有一系列元素，这一点和 list 很像，但是set的元素没有重复，而且是无序的，这点和 dict 的 key很像。创建 set 的方式是调用 set() 并传入一个 list，list的元素将作为set的元素：s = set(['A', 'B', 'C'])添加重复元素，重复元素最后只存在一个
由于set存储的是无序集合，所以我们没法通过索引来访问。

访问 set中的某个元素实际上就是判断一个元素是否在set中。
s = set(['Adam', 'Lisa', 'Bart', 'Paul'])
Bart是该班的同学吗？'Bart' in s输出True
遍历：
s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
for name in s:
    print name
输出('Lisa', 85)
('Adam', 95)
('Bart', 59)
添加元素时，用set的add()方法，删除set中的元素时，用set的remove()方法，不存在会报错

在Python中，定义一个函数要使用 def 语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用 return 语句返回。return None可以简写为return。
在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple
使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
Python自带的 int() 函数，其实就有两个参数，int()函数的第二个参数是转换进制，如果不传，默认是十进制 

(base=10)，如果传了，就用传入的参数。
可变参数的名字前面有个 * 号，我们可以传入0个、1个或多个参数给可变参数

在python2中有input和raw_input两个函数，其中raw_input将所有输入作为字符串看待，返回字符串类型。
input函数支持表达式、数字类型、字符串类型，接受为表达式时，只返回其执行结果。
在python3中对input和raw_input函数进行了整合，仅保留了input函数（认为raw_input函数是冗余的）。
同时改变了input的用法——将所有的输入按照字符串进行处理，并返回一个字符串。
 sqrt()方法返回x的平方根(x>0)。
语法
以下是sqrt()方法的语法：
import math

math.sqrt( x )
 
注意：此函数是无法直接访问的，所以我们需要导入math模块，然后需要用math的静态对象来调用这个函数。参数
1.    x -- 这是一个数值表达式。返回值
此方法返回x的平方根，对于x>0。例子下面的例子显示了sqrt()方法的使用。

#!/usr/bin/python
import math  # This will import math module
print "math.sqrt(100) : ", math.sqrt(100)
print "math.sqrt(7) : ", math.sqrt(7)
print "math.sqrt(math.pi) : ", math.sqrt(math.pi)

当我们运行上面的程序，它会产生以下结果：
math.sqrt(100) : 10.0
math.sqrt(7) : 2.64575131106
math.sqrt(math.pi) : 1.77245385091
map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上

，得到一个新的 list 并返回。注意：map()函数不改变原有的 list，而是返回一个新的 list。

在使用Python编译的时候出现如下错误：
SyntaxError: Non-ASCII character '\xe5' in file Test1.py on line 8, but no encoding declared; see 

http://www.python.org/peps/pep-0263.html for details
解决方法
python的默认编码文件是用的ASCII码，将文件存成了UTF-8，编译就可以通过。或在在py文件开头（必须是第一行）加入
[python] view plain copy
#coding=utf-8  
或者
[python] view plain copy
# -*- coding:utf-8 -*-  
原因
如果要在python2的py文件里面写中文，则必须要添加一行声明文件编码的注释，否则python2会默认使用ASCII编码。
可以使用unicode函数
print u'你好';
print (unicode("请输入销售额", encoding="utf-8"))
将utf-8编码转换为unicode就可以输出中文了。
将ASCII字符转换为对应的数值即‘a’-->65，使用ord函数,ord('a')
反正，使用chr函数，将数值转换为对应的ASCII字符，chr(65)

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。reduce()还可以接收第3个可选参数，作为计算的初始值。
例如，编写一个f函数，接收x和y，返回x和y的和：

def f(x, y):
    return x + y
调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。
filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter

()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
注意: s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。
当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')
Python内置的 sorted()函数可对list进行升序排序
但 sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元
素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。
定义一个函数 f()，我们让它返回一个函数 g，可以这样写：

def f():
    print 'call f()...'
    # 定义函数g:
    def g():
        print 'call g()...'
    # 返回函数g:
    return g
调用函数 f，我们会得到 f 返回的一个函数：

>>> x = f()   # 调用f()
call f()...
>>> x   # 变量x是f()返回的函数：
<function g at 0x1037bf320>
>>> x()   # x指向函数，因此可以调用
call g()...   # 调用x()就是执行g()函数定义的代码
内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：
# 希望一次返回3个函数，分别计算1x1,2x2,3x3:
def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。
原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：

>>> f1()
9     # 因为f1现在才计算i*i，但现在i的值已经变为3
因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。
def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()
输出1 4 9

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。
Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。
使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用。

在定义 Person 类时，可以为Person类添加一个特殊的__init__()方法，当创建实例时，__init__()方法被自动调用，我们就能在此为每个实例都统一加上以下属性：

class Person(object):
    def __init__(self, name, gender, birth):
        self.name = name
        self.gender = gender
        self.birth = birth
__init__() 方法的第一个参数必须是 self（也可以用别的名字，但建议使用习惯用法），后续参数则可以自由指定，和定义函数没有任何区别。

相应地，创建实例时，就必须要提供除 self 以外的参数：

xiaoming = Person('Xiao Ming', 'Male', '1991-1-1')
xiaohong = Person('Xiao Hong', 'Female', '1992-2-2')
只有以双下划线开头的"__job"不能直接被外部访问。
但是，如果一个属性以"__xxx__"的形式定义，那它又可以被外部访问了，以"__xxx__"定义的属性在Python的类中被称
为特殊属性，有很多预定义的特殊属性可以使用，通常我们不要把普通属性用"__xxx__"定义。
以单下划线开头的属性"_xxx"虽然也可以被外部访问，但是，按照习惯，他们不应该被外部访问。
在class中定义的全部是实例方法，实例方法第一个参数 self 是实例本身。
要在class中定义类方法，需要这么写：
class Person(object):
    count = 0
    @classmethod
    def how_many(cls):
        return cls.count
    def __init__(self, name):
        self.name = name
        Person.count = Person.count + 1
print Person.how_many()
p1 = Person('Bob')
print Person.how_many()
通过标记一个 @classmethod，该方法将绑定到 Person 类上，而非类的实例。类方法的第一个参数将传入类本身，通
常将参数名命名为 cls，上面的 cls.count 实际上相当于 Person.count。
因为是在类上调用，而非实例上调用，因此类方法无法获得任何实例变量，只能获得类的引用。
如果已经定义了Person类，需要定义新的Student和Teacher类时，可以直接从Person类继承：
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
定义Student类时，只需要把额外的属性加上，例如score：
class Student(Person):
    def __init__(self, name, gender, score):
        super(Student, self).__init__(name, gender)
        self.score = score
一定要用 super(Student, self).__init__(name, gender) 去初始化父类，否则，继承自 Person 的 Student 将没有 name 和 gender。
函数super(Student, self)将返回当前类继承的父类，即 Person ，然后调用__init__()方法，注意self参数已在
super()中传入，在__init__()中将隐式传递，不需要写出（也不能写）。
当我们拿到变量 p、s、t 时，可以使用 isinstance 判断类型：
>>> isinstance(p, Person)
True    # p是Person类型
>>> isinstance(p, Student)
False   # p不是Student类型
>>> isinstance(p, Teacher)
False   # p不是Teacher类型
对于实例变量，dir()返回所有实例属性，包括`__class__`这类有特殊意义的属性。注意到方法`whoAmI`也是 s 的一个属性。
如何去掉`__xxx__`这类的特殊属性，只保留我们自己定义的属性？回顾一下filter()函数的用法。
dir()返回的属性是字符串列表，如果已知一个属性名称，要获取或者设置对象的属性，就需要用 getattr() 和 setattr( )函数了：
>>> getattr(s, 'name')  # 获取name属性
'Bob'
>>> setattr(s, 'name', 'Adam')  # 设置新的name属性
>>> s.name
'Adam'
>>> getattr(s, 'age')  # 获取age属性，但是属性不存在，报错：
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute 'age'
>>> getattr(s, 'age', 20)  # 获取age属性，如果属性不存在，就返回默认值20：
20
如果要把一个类的实例变成 str，就需要实现特殊方法__str__()，Python 定义了__str__()和__repr__()两种方法，
__str__()用于显示给用户，而__repr__()用于显示给开发人员。
有一个偷懒的定义__repr__的方法：
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return '(Person: %s, %s)' % (self.name, self.gender)
    __repr__ = __str__
要让 len() 函数工作正常，类必须提供一个特殊方法__len__()，它返回元素的个数。例如，我们写一个 Students 类，把名字传进去：
class Students(object):
    def __init__(self, *args):
        self.names = args
    def __len__(self):
        return len(self.names)
对 int、str 等内置数据类型排序时，Python的 sorted() 按照默认的比较函数 cmp 排序，但是，如果对一组 
Student 类的实例排序时，就必须提供我们自己的特殊方法 __cmp__()：
class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def __str__(self):
        return '(%s: %s)' % (self.name, self.score)
    __repr__ = __str__
    def __cmp__(self, s):
        if self.name < s.name:
            return -1
        elif self.name > s.name:
            return 1
        else:
            return 0
上述 Student 类实现了__cmp__()方法，__cmp__用实例自身self和传入的实例 s 进行比较，如果 self 应该排在前
面，就返回 -1，如果 s 应该排在前面，就返回1，如果两者相当，返回 0。所有的函数都是可调用对象。
一个类实例也可以变成一个可调用对象，只需要实现一个特殊方法__call__()。
我们把 Person 类变成一个可调用对象：
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __call__(self, friend):
        print 'My name is %s...' % self.name
        print 'My friend is %s...' % friend
现在可以对 Person 实例直接调用：
>>> p = Person('Bob', 'male')
>>> p('Tim')
My name is Bob...
My friend is Tim...

Python进阶(二十一)-Python学习进阶资料
  学习Python已经将近2周了，掌握了基本的语法，并学习了简单的爬虫操作，现将相关学习资料整理如下。大部分资料均取材于慕课网，感觉一路学下来受益匪浅。

1.Python入门
2.Python进阶
3.Python装饰器
4.Python-面向对象
5.Python-走进Requests库
6.Python操作MySQL数据库
7.Python遇见数据采集
8.Python开发简单爬虫
9. 多线程爬虫
10. Django初体检
11.Django入门与实战
12.Flask 开发基础与入门
13.在 Flask 应用中使用 MySQL
14.Flask 与 BootStrap 搭建网页
  当然，这其中也不乏收费的教学视频。不过，Maybe可以在别的地方找到该资源~(窃喜)

15. Python分布式爬虫打造搜索引擎 Scrapy精讲
16. 强力django+杀手级xadmin 打造上线标准的在线教育平台
注
  Demo

Python进阶(一)-初识Python数据元素:列表&元组
Python不像JS或者PHP这种弱类型语言里在字符串连接时会自动转换类型，而是直接报错。要解决这个方法只有提前把int转成string，然后再拼接字符串即可。

如代码：

# coding=utf8

str='你的分数是:'

num=82

text=str+num+'分 | 琼台博客'

printtext
执行结果

直接报错：TypeError: cannot concatenate 'str' and 'int' objects

解决这个方法只有提前把num转换为字符串类型，可以使用bytes函数把int型转换为string型。

代码：

# coding=utf8

str='你的分数是:'

num=82

num=bytes(num)

text=str+num+'分 | 琼台博客'

printtext
结果搞定：

  毕业论文已完成，下面就是等待盲审结果了。在此期间，已感觉论文无从看起。就学习一下Python吧，听说这是一门很神奇的语言。下面言归正传~ 
  在线文档查询：点击查看 
  IDE：IntelJ。 
  有关IntelJ的安装与注册详见博文《IntelliJ IDEA 2016注册方法和注册码》。 
  下面介绍一下Python中几种不熟悉的数据元素：列表、元组、字典、时间。

1列表
1.1初始化列表
list=['physics', 'chemistry', 1997, 2000];
1.2访问列表中的值
list[0]
1.3更新列表
nums[0]="ljq";
1.4删除列表元素
del nums[0];
1.5列表脚本操作符
  列表对+和的操作符与字符串相似。+号用于组合列表，号用于重复列表，例如：

print len([1, 2, 3]); #3
print [1, 2, 3] + [4, 5, 6]; #[1, 2, 3, 4, 5, 6]
print ['Hi!'] * 4; #['Hi!', 'Hi!', 'Hi!', 'Hi!']
print 3 in [1, 2, 3] #True
for x in [1, 2, 3]: print x, #1 2 3
1.6列表截取
L=['spam', 'Spam', 'SPAM!'];
print L[2]; #'SPAM!'
print L[-2]; #'Spam'
print L[1:]; #['Spam', 'SPAM!']
1.7列表函数&方法
list.append(obj) #在列表末尾添加新的对象
list.count(obj) #统计某个元素在列表中出现的次数
list.extend(seq) #在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
list.index(obj) #从列表中找出某个值第一个匹配项的索引位置，索引从0开始
list.insert(index, obj) #将对象插入列表
list.pop(obj=list[-1]) #移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
list.remove(obj) #移除列表中某个值的第一个匹配项
list.reverse() #反向列表中元素，倒转
list.sort([func]) #对原列表进行排序
2元组(tuple)
  Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，

tup1 = ('physics', 'chemistry', 1997, 2000);
 创建空元组，例如：

tup = ();
  元组中只有一个元素时，需要在元素后面添加逗号，例如：

tup1 = (50,);
  元组与字符串类似，下标索引从0开始，可以进行截取，组合等。

2.1访问元组
tup1 = ('physics', 'chemistry', 1997, 2000);
tup1[0]#physics
2.2修改元组
  元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:

tup1 = (12, 34.56);
tup2 = ('abc', 'xyz');
 #以下修改元组元素操作是非法的。
 tup1[0] = 100;
 #创建一个新的元组
 tup3 = tup1 + tup2;
 print tup3; #(12, 34.56, 'abc', 'xyz')
2.3删除元组
  元组中的元素值是不允许删除的，可以使用del语句来删除整个元组，例如:

tup = ('physics', 'chemistry', 1997, 2000);
print tup;
del tup;
2.4元组运算符
  与字符串一样，元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。 

2.5元组索引&截取
L = ('spam', 'Spam', 'SPAM!');
print L[2]; #'SPAM!'
print L[-2]; #'Spam'
print L[1:]; #['Spam', 'SPAM!']
2.6元组内置函数
cmp(tuple1, tuple2) 比较两个元组元素。
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(seq) 将列表转换为元组。

Python进阶(二)-初识Python数据元素:字典&时间
3字典
3.1字典简介
  字典(dic dictionary)是除列表之外python中最灵活的内置数据结构类型。 列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。 
  字典由键和对应的值组成。字典也被称作关联数组或哈希表。基本语法如下：

dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'};
  也可如此创建字典：

dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
  每个键与值必须用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。

3.2访问字典里的值
dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
print "dict['name']: ", dict['name'];
print "dict['age']: ", dict['age'];
3.3修改字典
  向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。 
如下实例:

dict = {'name': 'Zara', 'age': 7, 'class': 'First'};
dict["age"]=27; #修改已有键的值
dict["school"]="wutong"; #增加新的键/值对
print "dict['age']: ", dict['age'];
print "dict['school']: ", dict['school'];
3.4删除字典
del dict['name']; # 删除键是'name'的条目
dict.clear(); # 清空词典所有条目
del dict ; # 删除词典
注意：字典不存在，del会引发一个异常
3.5字典内置函数&方法
cmp(dict1, dict2) #比较两个字典元素。
len(dict) #计算字典元素个数，即键的总数。
str(dict) #输出字典可打印的字符串表示。
type(variable) #返回输入的变量类型，如果变量是字典就返回字典类型。
clear() #删除字典内所有元素
copy() #返回一个字典的浅复制
fromkeys() #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
get(key, default=None) #返回指定键的值，如果值不在字典中返回default值
has_key(key) #如果键在字典dict里返回true，否则返回false
items() #以列表返回可遍历的(键, 值) 元组数组
keys() #以列表返回一个字典所有的键
setdefault(key, default=None) #和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
update(dict2) #把字典dict2的键/值对更新到dict里
values() #以列表返回字典中的所有值
4日期和时间
4.1获取当前时间
import time, datetime;
localtime = time.localtime(time.time())
print "Local current time :", localtime
  说明：time.struct_time(tm_year=2014, tm_mon=3, tm_mday=21, tm_hour=15, tm_min=13, tm_sec=56, tm_wday=4, tm_yday=80, tm_isdst=0)属于struct_time元组，struct_time元组具有如下属性： 

4.2获取格式化的时间
  可以根据需求选取各种格式，但是最简单的获取可读的时间模式的函数是asctime():

4.2.1日期转换为字符串
  首选：print time.strftime(‘%Y-%m-%d %H:%M:%S’); 
  其次：print datetime.datetime.strftime(datetime.datetime.now(), ‘%Y-%m-%d %H:%M:%S’) 
  最后：print str(datetime.datetime.now())[:19]

4.2.2字符串转换为日期
expire_time = "2013-05-21 09:50:35"
d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
print d;

4.2.3获取日期差
oneday = datetime.timedelta(days=1)
#今天，2014-03-21
today = datetime.date.today()
#昨天，2014-03-20
yesterday = datetime.date.today() - oneday
#明天，2014-03-22
tomorrow = datetime.date.today() + oneday
#获取今天零点的时间，2014-03-21 00:00:00
today_zero_time=datetime.datetime.strftime(today, '%Y-%m-%d %H:%M:%S')
#0:00:00.001000 
print datetime.timedelta(milliseconds=1), #1毫秒
#0:00:01 
print datetime.timedelta(seconds=1), #1秒
#0:01:00 
print datetime.timedelta(minutes=1), #1分钟
#1:00:00 
print datetime.timedelta(hours=1), #1小时
#1 day, 0:00:00 
print datetime.timedelta(days=1), #1天
#7 days, 0:00:00
print datetime.timedelta(weeks=1)

4.2.4获取时间差
#1 day, 0:00:00
oneday = datetime.timedelta(days=1)
#今天，2014-03-21 16:07:23.943000
today_time = datetime.datetime.now()
#昨天，2014-03-20 16:07:23.943000
yesterday_time = datetime.datetime.now() - oneday
#明天，2014-03-22 16:07:23.943000
tomorrow_time = datetime.datetime.now() + oneday

  注意时间是浮点数，带毫秒。 
  那么要获取当前时间，需要格式化一下：

print datetime.datetime.strftime(today_time, '%Y-%m-%d %H:%M:%S')
print datetime.datetime.strftime(yesterday_time, '%Y-%m-%d %H:%M:%S')
print datetime.datetime.strftime(tomorrow_time, '%Y-%m-%d %H:%M:%S')

4.2.5获取上个月最后一天
last_month_last_day = datetime.date(datetime.date.today().year,datetime.date.today().month,1)-datetime.timedelta(1)
1
4.2.6字符串日期格式化为秒数
  返回浮点类型

expire_time = "2013-05-21 09:50:35"
d = datetime.datetime.strptime(expire_time,"%Y-%m-%d %H:%M:%S")
time_sec_float = time.mktime(d.timetuple())
print time_sec_float

4.2.7日期格式化为秒数
  返回浮点类型

d = datetime.date.today()
time_sec_float = time.mktime(d.timetuple())
print time_sec_float

4.2.8秒数转字符串
time_sec = time.time()
print time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time_sec))

Python进阶(三)-函数式编程之reduce()
  官方解释如下： 
  Apply function of two arguments cumulatively to the items of sequence, from left to right, so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the sequence. If the optional initializer is present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty. If initializer is not given and sequence contains only one item, the first item is returned. 
  格式： reduce (func, seq[, init()]) 
  reduce()函数即为化简函数，它的执行过程为：每一次迭代，都将上一次的迭代结果（注：第一次为init元素，如果没有指定init则为seq的第一个元素）与下一个元素一同传入二元func函数中去执行。在reduce()函数中，init是可选的，如果指定，则作为第一次迭代的第一个元素使用，如果没有指定，就取seq中的第一个元素。

举例
  有一个序列集合，例如[1,1,2,3,2,3,3,5,6,7,7,6,5,5,5],统计这个集合所有键的重复个数，例如1出现了两次，2出现了两次等。大致的思路就是用字典存储，元素就是字典的key,出现的次数就是字典的value。方法依然很多 
第一种：for循环判断

def statistics(lst): 
  dic = {} 
  for k in lst: 
    if not k in dic: 
      dic[k] = 1
    else: 
      dic[k] +=1
  return dic
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5] 
print(statistics(lst)) 

第二种：比较取巧的，先把列表用set方式去重，然后用列表的count方法

def statistics2(lst): 
  m = set(lst) 
  dic = {} 
  for x in m: 
    dic[x] = lst.count(x) 
  return dic
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5] 
print statistics2(lst) 

第三种：用reduce方式

def statistics(dic,k):
  if not k in dic:
    dic[k] = 1
  else:
    dic[k] +=1
  return dic
lst = [1,1,2,3,2,3,3,5,6,7,7,6,5,5,5]
print reduce(statistics,lst,{}) 
#提供第三个参数，第一次，初始字典为空，作为statistics的第一个参数，然后遍历lst,作为第二个参数，然后将返回的字典集合作为下一次的第一个参数
或者 
d = {} 
d.extend(lst) 
print reduce(statistics,d) 
#不提供第三个参数，但是要在保证集合的第一个元素是一个字典对象，作为statistics的第一个参数，遍历集合依次作为第二个参数 

  通过上面的例子发现,凡是要对一个集合进行操作的，并且要有一个统计结果的，能够用循环或者递归方式解决的问题，一般情况下都可以用reduce方式实现。

Python进阶(四)-浅谈Python闭包
  在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问：

def g():
    print 'g()...'
def f():
    print 'f()...'
    return g

  将 g 的定义移入函数 f 内部，防止其他代码调用 g：

def f():
    print 'f()...'
    def g():
        print 'g()...'
    return g

  但是，考察定义的 calc_sum 函数：

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

  注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
  闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：

# 希望一次返回3个函数，分别计算1x1,2x2,3x3:
def count():
    fs = [ ]
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs
f1, f2, f3 = count()

  你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。 
  原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：

>>> f1()
9     # 因为f1现在才计算i*i，但现在i的值已经变为3

  因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。

举例
  返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。 
  考察下面的函数 f:

def f(j):
    def g():
        return j*j
    return g

  它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。 
  在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。 
  参考代码:

def count():
    fs = []
    for i in range(1, 4):
        def f(j):
            def g():
                return j*j
            return g
        r = f(i)
        fs.append(r)
    return fs
f1, f2, f3 = count()
print f1(), f2(), f3()

程序实例

Python进阶(五)-浅谈python匿名函数
  高阶函数可以接收函数做参数，有些时候，我们不需要显式地定义函数，直接传入匿名函数更方便。 
  在Python中，对匿名函数提供了有限支持。还是以map()函数为例，计算 f(x)=x2 时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：

>>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])
[1, 4, 9, 16, 25, 36, 49, 64, 81]

  通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：

def f(x):
    return x * x

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
  匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。 
  使用匿名函数，可以不必定义函数名，直接创建一个函数对象，很多时候可以简化代码：

>>> sorted([1, 3, 9, 5, 0], lambda x,y: -cmp(x,y))
[9, 5, 3, 1, 0]

  返回函数的时候，也可以返回匿名函数：

>>> myabs = lambda x: -x if x < 0 else x 
>>> myabs(-1)

>>> myabs(1)

举例
  利用匿名函数简化以下代码：

def is_not_empty(s):
    return s and len(s.strip()) > 0
filter(is_not_empty, ['test', None, '', 'str', '  ', 'END'])

  定义匿名函数时，没有return关键字，且表达式的值就是函数返回值。 
参考代码:

print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])

Python进阶(六)-python编写无参数decorator
  Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。 
  使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。 
  考察一个@log的定义：

def log(f):
    def fn(x):
        print 'call ' + f.__name__ + '()...'
        return f(x)
    return fn

  对于阶乘函数，@log工作得很好：

@log
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

  结果： 
  call factorial()… 
  3628800 
  但是，对于参数不是一个的函数，调用将报错：

@log
def add(x, y):
    return x + y
print add(1, 2)

  结果： 
  Traceback (most recent call last): 
   File “test.py”, line 15, in 
   print add(1,2) 
  TypeError: fn() takes exactly 1 argument (2 given) 
  因为 add() 函数需要传入两个参数，但是 @log 写死了只含一个参数的返回函数。 
  要让 @log 自适应任何参数定义的函数，可以利用Python的 *args 和 **kw，保证任意个数的参数总是能正常调用：

def log(f):
    def fn(*args, **kw):
        print 'call ' + f.__name__ + '()...'
        return f(*args, **kw)
    return fn

  现在，对于任意函数，@log 都能正常工作。

举例
  请编写一个@performance，它可以打印出函数调用的时间。 
  计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差。 
  参考代码:

import time
def performance(f):
    def fn(*args, **kw):
        t1 = time.time()
        r = f(*args, **kw)
        t2 = time.time()
        print 'call %s() in %fs' % (f.__name__, (t2 - t1))
        return r
    return fn
 
@performance
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

Python进阶(七)-浅谈python3和Python2的区别
  不管使用何种版本的Python语言，都需要遵循编程规范，不该有的缩进一定不能有。否则会出现莫名其妙的错误，如下图所示： 

  在应用Python编程时，首先要明确所使用Python版本，因为版本2与3之间存在着很多细节性的差异。稍有不慎就会入坑~下面介绍一下具体应用中的细节性差异。 
  具体参照：https://docs.python.org/3/whatsnew/3.0.html

print函数
  Python3中print为一个函数，必须用括号括起来；Python2中print为class）。Python 2 的 print 声明已经被 print() 函数取代了，这意味着我们必须包装我们想打印在小括号中的对象。

举例
在Python 2中：

print 'Hello, World!'

在Python 3中：

print( 'Hello, World!')

reduce()函数
  在Python 3里，reduce()函数已经被从全局名字空间里移除了，它现在被放置在fucntools模块里。使用时要先引入from functools import reduce

try except
try: 
except Exception, e :

    try:
         except    Exception as e :

打开文件
原： file( ….. ) 
或 open(…..) 
改为： 
只能用 open(…..)

从键盘录入一个字符串
原: raw_input( “提示信息” ) 
改为: input( “提示信息” )

整形除法自动转为float
python2： 
1/2 
2/2 
1//2 
0 
1 
0 
python3： 
1/2 
2/2 
1//2 
0.5 
1.0 
0

新的字符串格式化方法format取代%5.
xrange重命名为range.
!=取代 < >
long重命名为int.
exec变成函数
Py3.X源码文件默认使用utf-8编码，这就使得以下代码是合法的：
    >>> 中国 = 'china' 
    >>>print(中国) 
    china 
python3中替换python2中cmp函数
  Python 3.4.3 的版本中已经没有cmp函数，被operator模块代替，在交互模式下使用时，需要导入模块。在没有导入模块情况下，会出现下面的错误： 
 
  提示找不到cmp函数了，那么在python3中该如何使用这个函数呢？ 
  所以要导入模块 
 
看下面给的内置函数

operator.lt(a, b)     #相当于 a<b 从第一个数字或字母（ASCII）比大小
operator.le(a, b)     #相当于a<=b
operator.eq(a, b)     #相当于a==b 字母完全一样，返回True
operator.ne(a, b)     #相当于a!=b
operator.ge(a, b)     #相当于 a>=b
operator.gt(a, b)     #相当于a>b
operator.__lt__(a, b)     
operator.__le__(a, b)     
operator.__eq__(a, b)     
operator.__ne__(a, b)     
operator.__ge__(a, b)     
operator.__gt__(a, b)

  这几个函数就是用来替换之前的cmp，函数的返回值是布尔值。

除法
在python3.0中，/ 现在总是执行真除法，不管操作数的类型，都会返回包含任何余数的一个浮点结果。// 执行Floor除法，它截除掉余数并且针对整数操作数返回一个整数，如果有任何一个操作数是浮点数类型，则返回一个浮点数。
在python2.6中，/ 表示传统除法，如果两个操作数都是整数的话，执行截断的整数除法(好像是Floor除法？？？？)；否则，执行浮点除法(保留余数，好像是真除法？)。//执行Floor除法，并且像在python3.0中一样工作，对于整数执行截断除法，对于浮点数执行浮点除法。

Python进阶(八)-编写带参数decorator
  继续考察@log 装饰器：

def log(f):
    def fn(x):
        print 'call ' + f.__name__ + '()...'
        return f(x)
    return fn

  发现对于被装饰的函数，log打印的语句是不能变的（除了函数名）。 
  如果有的函数非常重要，希望打印出’[INFO] call xxx()…’，有的函数不太重要，希望打印出’[DEBUG] call xxx()…’，这时，log函数本身就需要传入’INFO’或’DEBUG’这样的参数，类似这样：

@log('DEBUG')
def my_func():
    pass

  把上面的定义翻译成高阶函数的调用，就是：

my_func = log('DEBUG')(my_func)

  上面的语句看上去还是比较绕，再展开一下：

log_decorator = log('DEBUG')
my_func = log_decorator(my_func)

  上面的语句又相当于：

log_decorator = log('DEBUG')
@log_decorator
def my_func():
    pass

  所以，带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数：

def log(prefix):
    def log_decorator(f):
        def wrapper(*args, **kw):
            print '[%s] %s()...' % (prefix, f.__name__)
            return f(*args, **kw)
        return wrapper
    return log_decorator
 
@log('DEBUG')
def test():
    pass
print test()

执行结果： 
[DEBUG] test()… 
None 
  对于这种3层嵌套的decorator定义，你可以先把它拆开：

# 标准decorator:
def log_decorator(f):
    def wrapper(*args, **kw):
        print '[%s] %s()...' % (prefix, f.__name__)
        return f(*args, **kw)
    return wrapper
return log_decorator
 
# 返回decorator:
def log(prefix):
    return log_decorator(f)

  拆开以后会发现，调用会失败，因为在3层嵌套的decorator定义中，最内层的wrapper引用了最外层的参数prefix，所以，把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。

举例
  在@performance实现打印秒的同时，请给 @performace 增加一个参数，允许传入’s’或’ms’：

@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))

  要实现带参数的@performance，就需要实现：

my_func = performance('ms')(my_func)

需要3层嵌套的decorator来实现。 
参考代码:

import time
def performance(unit):
    def perf_decorator(f):
        def wrapper(*args, **kw):
            t1 = time.time()
            r = f(*args, **kw)
            t2 = time.time()
            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)
            print 'call %s() in %f %s' % (f.__name__, t, unit)
            return r
        return wrapper
    return perf_decorator
 
@performance('ms')
def factorial(n):
    return reduce(lambda x,y: x*y, range(1, n+1))
print factorial(10)

Python进阶(九)-Python陷阱：Nonetype
  今天解决一位网友的问题，内容如下： 
  请教代码问题

def calc_prod(lst):
    def ff():
        print map(lambda x:x*x,lst)
    return ff
 
f = calc_prod([1, 2, 3, 4])
print f()

结果： 
[1, 4, 9, 16] 
None 
  这样写输出为什么有None 
  针对这一问题，自己在IDEA中进行了调试，发现果然多输出了一行None。出现这一现象确实很令人费解。 
自己写了简单的测试语句，如下：

b = print(5)
print(b)

通过断点调试，内容如下： 
 
  发现b的值确实为None，且其类型为NoneType。

那么什么是Nonetype？
  要理解这个，首先要理解Python对象，python对象具有三个特性：身份、类型、值。 
  这三个特性在对象创建时被赋值。只有值可以改变，其他只读。类型本身也是对象。 
  Null与None是Python的特殊类型，Null对象或者是None Type，它只有一个值None. 
  它不支持任何运算也没有任何内建方法. None和任何其他的数据类型比较永远返回False。 
  None有自己的数据类型NoneType。你可以将None复制给任何变量，但是你不能创建其他NoneType对象。 
  一句话总结：Null对象是python对象，又叫做NoneType，None是这个对象的值。 
  看过了NoneType的解释，之所以出现None就很好理解了。 
  NoneType之所以出现是因为定义了一个变量或函数，却没有值或者返回值，因此会默认值为None。 
  而在上面的程序中，虽然高阶函数calc_prod()有返回值ff，但是ff()却没有返回值，则传递到外层函数calc_prod()同样没有返回值，故输出了None。 若代码改为如下所示，则可以完美实现列表的输出。

def calc_prod(lst):
    def ff():
        return map(lambda x:x*x,lst)
    return ff
 
    f = calc_prod([1, 2, 3, 4])
    print(f())

Python进阶(十)-Python 编程规范
  在学习一门新的编程语言时，掌握其良好的编程规范可避免一些细节性错误的发生。去除一些不必要的学习障碍。

分号
  不要在行尾加分号, 也不要用分号将两条命令放在同一行. 
行长度 
  每行不超过80个字符 
例外:

1.长的导入模块语句
2.注释里的URL
  不要使用反斜杠连接行. 
  Python会将圆括号, 中括号和花括号中的行隐式连接起来 , 你可以利用这个特点. 如果需要, 你可以在表达式外围增加一对额外的圆括号.

foo_bar(self, width, height, color='black', design=None, x='foo',emphasis=None, highlight=0)
     if (width == 0 and height == 0 and
         color == 'red' and emphasis == 'strong'):

  如果一个文本字符串在一行放不下, 可以使用圆括号来实现隐式行连接:

x = ('This will build a very long long '
     'long long long long long long string')

  在注释中，如果必要，将长的URL放在一行上。 
Yes:

# See details at
# http://www.example.com/us/developer/documentation/api/content/v2.0/csv_file_name_extension_full_specification.html

No:

# See details at
# http://www.example.com/us/developer/documentation/api/content/\
# v2.0/csv_file_name_extension_full_specification.html

注意上面例子中的元素缩进; 你可以在本文的缩进部分找到解释.

括号
  宁缺毋滥的使用括号 
  除非是用于实现行连接, 否则不要在返回语句或条件语句中使用括号. 不过在元组两边使用括号是可以的. 
Yes:

 if foo:
         bar()
     while x:
         x = bar()
     if x and y:
         bar()
     if not x:
         bar()
     return foo
     for (x, y) in dict.items(): ...

No:

 if (x):
         bar()
     if not(x):
         bar()
     return (foo)

缩进
  用4个空格来缩进代码 
  绝对不要用tab, 也不要tab和空格混用. 对于行连接的情况, 你应该要么垂直对齐换行的元素(见行长度部分的示例), 或者使用4空格的悬挂式缩进(这时第一行不应该有参数): 
Yes:

       # Aligned with opening delimiter
       foo = long_function_name(var_one, var_two,
                                var_three, var_four)
 
       # Aligned with opening delimiter in a dictionary
       foo = {
           long_dictionary_key: value1 +
                                value2,
           ...
       }
 
       # 4-space hanging indent; nothing on first line
       foo = long_function_name(
           var_one, var_two, var_three,
           var_four)
 
       # 4-space hanging indent in a dictionary
       foo = {
           long_dictionary_key:
               long_dictionary_value,
           ...
       }

No:

      # Stuff on first line forbidden
      foo = long_function_name(var_one, var_two,
          var_three, var_four)
 
      # 2-space hanging indent forbidden
      foo = long_function_name(
        var_one, var_two, var_three,
        var_four)
 
      # No hanging indent in a dictionary
      foo = {
          long_dictionary_key:
              long_dictionary_value,
              ...
      }

空行
  顶级定义之间空两行, 方法定义之间空一行 
  顶级定义之间空两行, 比如函数或者类定义. 方法定义, 类定义与第一个方法之间, 都应该空一行. 函数或方法中, 某些地方要是你觉得合适, 就空一行.

空格
  按照标准的排版规范来使用标点两边的空格。 
  括号内不要有空格. 
Yes:

spam(ham[1], {eggs: 2}, [])

No:

spam( ham[ 1 ], { eggs: 2 }, [ ] )

  不要在逗号, 分号, 冒号前面加空格, 但应该在它们后面加(除了在行尾). 
Yes:

if x == 4:
         print x, y
     x, y = y, x
     ```
No:  

if x == 4 : 
print x , y 
x , y = y , x

参数列表, 索引或切片的左括号前不应加空格.
Yes: spam(1)
no: spam (1)
Yes: dict['key'] = list[index]
No:  dict ['key'] = list [index]
在二元操作符两边都加上一个空格, 比如赋值(=), 比较(==, <, >, !=, <>, <=, >=, in, not in, is, is not), 布尔(and, or, not). 至于算术操作符两边的空格该如何使用, 需要你自己好好判断. 不过两侧务必要保持一致.
Yes: x == 1
No:  x<1
当’=’用于指示关键字参数或默认参数值时, 不要在其两侧使用空格.
Yes: def complex(real, imag=0.0): return magic(r=real, i=imag)
No:  def complex(real, imag = 0.0): return magic(r = real, i = imag)
不要用空格来垂直对齐多行间的标记, 因为这会成为维护的负担(适用于:, #, =等):
Yes:

 foo = 1000  # comment
 long_name = 2  # comment that should not be aligned
 dictionary = {
     "foo": 1,
     "long_name": 2,
     }
No:

 foo        = 1000  # comment
 long_name  = 2     # comment that should not be aligned
 dictionary = {
     "foo"      : 1,
     "long_name": 2,
     }
Shebang
  大部分.py文件不必以#!作为文件的开始. 根据 PEP-394 , 程序的main文件应该以 #!/usr/bin/python2或者 #!/usr/bin/python3开始. 
  (译者注: 在计算机科学中, Shebang (也称为Hashbang)是一个由井号和叹号构成的字符串行(#!), 其出现在文本文件的第一行的前两个字符. 在文件中存在Shebang的情况下, 类Unix操作系统的程序载入器会分析Shebang后的内容, 将这些内容作为解释器指令, 并调用该指令, 并将载有Shebang的文件路径作为该解释器的参数. 例如, 以指令#!/bin/sh开头的文件在执行时会实际调用/bin/sh程序.) 
  #!先用于帮助内核找到Python解释器, 但是在导入模块时, 将会被忽略. 因此只有被直接执行的文件中才有必要加入#!.

注释
  确保对模块, 函数, 方法和行内注释使用正确的风格

文档字符串
  Python有一种独一无二的的注释方式: 使用文档字符串. 文档字符串是包, 模块, 类或函数里的第一个语句. 这些字符串可以通过对象的doc成员被自动提取, 并且被pydoc所用. (你可以在你的模块上运行pydoc试一把, 看看它长什么样). 我们对文档字符串的惯例是使用三重双引号”“”( PEP-257 ). 一个文档字符串应该这样组织: 首先是一行以句号, 问号或惊叹号结尾的概述(或者该文档字符串单纯只有一行). 接着是一个空行. 接着是文档字符串剩下的部分, 它应该与文档字符串的第一行的第一个引号对齐. 下面有更多文档字符串的格式化规范.

模块
  每个文件应该包含一个许可样板. 根据项目使用的许可(例如, Apache 2.0, BSD, LGPL, GPL), 选择合适的样板. 
函数和方法 
下文所指的函数,包括函数, 方法, 以及生成器. 
一个函数必须要有文档字符串, 除非它满足以下条件: 
外部不可见 
非常短小 
简单明了 
  文档字符串应该包含函数做什么, 以及输入和输出的详细描述. 通常, 不应该描述”怎么做”, 除非是一些复杂的算法. 文档字符串应该提供足够的信息, 当别人编写代码调用该函数时, 他不需要看一行代码, 只要看文档字符串就可以了. 对于复杂的代码, 在代码旁边加注释会比使用文档字符串更有意义. 
  关于函数的几个方面应该在特定的小节中进行描述记录， 这几个方面如下文所述. 每节应该以一个标题行开始. 标题行以冒号结尾. 除标题行外, 节的其他内容应被缩进2个空格. 
Args: 
  列出每个参数的名字, 并在名字后使用一个冒号和一个空格, 分隔对该参数的描述.如果描述太长超过了单行80字符,使用2或者4个空格的悬挂缩进(与文件其他部分保持一致). 描述应该包括所需的类型和含义. 如果一个函数接受*foo(可变长度参数列表)或者**bar (任意关键字参数), 应该详细列出*foo和**bar. 
Returns: (或者 Yields: 用于生成器) 
  描述返回值的类型和语义. 如果函数返回None, 这一部分可以省略. 
Raises: 
列出与接口有关的所有异常.

def fetch_bigtable_rows(big_table, keys, other_silly_variable=None):
    """Fetches rows from a Bigtable.
    Retrieves rows pertaining to the given keys from the Table instance
    represented by big_table.  Silly things may happen if
    other_silly_variable is not None.
    Args:
        big_table: An open Bigtable Table instance.
        keys: A sequence of strings representing the key of each table row
            to fetch.
        other_silly_variable: Another optional variable, that has a much
            longer name than the other args, and which does nothing.
    Returns:
        A dict mapping keys to the corresponding table row data
        fetched. Each row is represented as a tuple of strings. For
        example:
        {'Serak': ('Rigel VII', 'Preparer'),
         'Zim': ('Irk', 'Invader'),
         'Lrrr': ('Omicron Persei 8', 'Emperor')}
        If a key from the keys argument is missing from the dictionary,
        then that row was not found in the table.
    Raises:
        IOError: An error occurred accessing the bigtable.Table object.
    """
    pass

类
  类应该在其定义下有一个用于描述该类的文档字符串. 如果你的类有公共属性(Attributes), 那么文档中应该有一个属性(Attributes)段. 并且应该遵守和函数参数相同的格式.

class SampleClass(object):
    """Summary of class here.
    Longer class information....
    Longer class information....
    Attributes:
        likes_spam: A boolean indicating if we like SPAM or not.
        eggs: An integer count of the eggs we have laid.
    """
 
    def __init__(self, likes_spam=False):
        """Inits SampleClass with blah."""
        self.likes_spam = likes_spam
        self.eggs = 0
 
    def public_method(self):
        """Performs operation blah."""

块注释和行注释
  最需要写注释的是代码中那些技巧性的部分. 如果你在下次代码审查的时候必须解释一下, 那么你应该现在就给它写注释. 对于复杂的操作, 应该在其操作开始前写上若干行注释. 对于不是一目了然的代码, 应在其行尾添加注释.

‘# We use a weighted dictionary search to find out where i is in 
‘# the array. We extrapolate position based on the largest num 
‘# in the array and the array size and then do binary search to 
‘# get the exact number.’

if i & (i-1) == 0: # true iff i is a power of 2

  为了提高可读性, 注释应该至少离开代码2个空格. 
  另一方面, 绝不要描述代码. 假设阅读代码的人比你更懂Python, 他只是不知道你的代码要做什么.

‘# BAD COMMENT: Now go through the b array and make sure whenever i occurs 
‘# the next element is i+1

类
  如果一个类不继承自其它类, 就显式的从object继承. 嵌套类也一样. 
Yes: class SampleClass(object): 
pass 
class OuterClass(object): 
class InnerClass(object): 
pass 
class ChildClass(ParentClass): 
“”“Explicitly inherits from another class already.”“” 
No: class SampleClass: 
pass 
class OuterClass: 
class InnerClass: 
pass

  继承自 object 是为了使属性(properties)正常工作, 并且这样可以保护你的代码, 使其不受Python 3的一个特殊的潜在不兼容性影响. 这样做也定义了一些特殊的方法, 这些方法实现了对象的默认语义, 包括 new, init, delattr, getattribute, setattr, hash, repr, and str .

字符串
  即使参数都是字符串, 使用%操作符或者格式化方法格式化字符串. 不过也不能一概而论, 你需要在+和%之间好好判定. 
Yes: x = a + b 
x = ‘%s, %s!’ % (imperative, expletive) 
x = ‘{}, {}!’.format(imperative, expletive) 
x = ‘name: %s; score: %d’ % (name, n) 
x = ‘name: {}; score: {}’.format(name, n) 
No: x = ‘%s%s’ % (a, b) # use + in this case 
x = ‘{}{}’.format(a, b) # use + in this case 
x = imperative + ‘, ’ + expletive + ‘!’ 
x = ‘name: ’ + name + ‘; score: ’ + str(n) 
  避免在循环中用+和+=操作符来累加字符串. 由于字符串是不可变的, 这样做会创建不必要的临时对象, 并且导致二次方而不是线性的运行时间. 作为替代方案, 你可以将每个子串加入列表, 然后在循环结束后用 .join 连接列表. (也可以将每个子串写入一个 cStringIO.StringIO 缓存中.) 
Yes: items = [‘

‘] 
for last_name, first_name in employee_list: 
items.append(‘’ % (last_name, first_name)) 
items.append(‘
%s, %s
‘) 
employee_table = ”.join(items) 
No: employee_table = ‘’ 
for last_name, first_name in employee_list: 
employee_table += ‘’ % (last_name, first_name) 
employee_table += ‘
%s, %s
’ 
  在同一个文件中, 保持使用字符串引号的一致性. 使用单引号’或者双引号”之一用以引用字符串, 并在同一文件中沿用. 在字符串内可以使用另外一种引号, 以避免在字符串中使用. GPyLint已经加入了这一检查.
(译者注:GPyLint疑为笔误, 应为PyLint.) 
Yes: 
Python(‘Why are you hiding your eyes?’) 
Gollum(“I’m scared of lint errors.”) 
Narrator(‘“Good!” thought a happy Python reviewer.’) 
No: 
Python(“Why are you hiding your eyes?”) 
Gollum(‘The lint. It burns. It burns us.’) 
Gollum(“Always the great lint. Watching. Watching.”) 
  为多行字符串使用三重双引号”“”而非三重单引号’‘’. 当且仅当项目中使用单引号’来引用字符串时, 才可能会使用三重’‘’为非文档字符串的多行字符串来标识引用. 文档字符串必须使用三重双引号”“”. 不过要注意, 通常用隐式行连接更清晰, 因为多行字符串与程序其他部分的缩进方式不一致. 
Yes: 
print (“This is much nicer.\n” 
“Do it this way.\n”) 
No: 
print “”“This is pretty ugly. 
Don’t do this. 
“”“

文件和sockets
  在文件和sockets结束时, 显式的关闭它. 
  除文件外, sockets或其他类似文件的对象在没有必要的情况下打开, 会有许多副作用, 例如:

1.它们可能会消耗有限的系统资源, 如文件描述符. 如果这些资源在使用后没有及时归还系统, 那么用于处理这些对象的代码会将资源消耗殆尽.
2.持有文件将会阻止对于文件的其他诸如移动、删除之类的操作.
3.仅仅是从逻辑上关闭文件和sockets, 那么它们仍然可能会被其共享的程序在无意中进行读或者写操作. 只有当它们真正被关闭后, 对于它们尝试进行读或者写操作将会抛出异常, 并使得问题快速显现出来.

  而且, 幻想当文件对象析构时, 文件和sockets会自动关闭, 试图将文件对象的生命周期和文件的状态绑定在一起的想法, 都是不现实的. 因为有如下原因:

1.没有任何方法可以确保运行环境会真正的执行文件的析构.不同的Python实现采用不同的内存管理技术, 比如延时垃圾处理机制. 延时垃圾处理机制可能会导致对象生命周期被任意无限制的延长.
2.对于文件意外的引用,会导致对于文件的持有时间超出预期(比如对于异常的跟踪, 包含有全局变量等).
  推荐使用 “with”语句 以管理文件:

with open("hello.txt") as hello_file:
    for line in hello_file:
        print line

  对于不支持使用”with”语句的类似文件的对象,使用

contextlib.closing():
import contextlib
with contextlib.closing(urllib.urlopen("http://www.python.org/")) as front_page:
    for line in front_page:
        print line
Legacy AppEngine 中Python 2.5的代码如使用”with”语句, 需要添加 “from __future__ import with_statement”.

TODO注释
  为临时代码使用TODO注释, 它是一种短期解决方案. 不算完美, 但够好了. 
  TODO注释应该在所有开头处包含”TODO”字符串, 紧跟着是用括号括起来的你的名字, email地址或其它标识符. 然后是一个可选的冒号. 接着必须有一行注释, 解释要做什么. 主要目的是为了有一个统一的TODO格式, 这样添加注释的人就可以搜索到(并可以按需提供更多细节). 写了TODO注释并不保证写的人会亲自解决问题. 当你写了一个TODO, 请注上你的名字.

‘# TODO(kl@gmail.com): Use a “*” here for string repetition. 
‘# TODO(Zeke) Change this to use relations. 
“`

  如果你的TODO是”将来做某事”的形式, 那么请确保你包含了一个指定的日期(“2009年11月解决”)或者一个特定的事件(“等到所有的客户都可以处理XML请求就移除这些代码”).

导入格式
  每个导入应该独占一行 
Yes: import os 
import sys 
No: import os, sys 
  导入总应该放在文件顶部, 位于模块注释和文档字符串之后, 模块全局变量和常量之前. 导入应该按照从最通用到最不通用的顺序分组: 
标准库导入 
第三方库导入 
应用程序指定导入 
每种分组中, 应该根据每个模块的完整包路径按字典序排序, 忽略大小写. 
import foo 
from foo import bar 
from foo.bar import baz 
from foo.bar import Quux 
from Foob import ar

语句
通常每个语句应该独占一行 
不过, 如果测试结果与测试语句在一行放得下, 你也可以将它们放在同一行. 如果是if语句, 只有在没有else时才能这样做. 特别地, 绝不要对 try/except 这样做, 因为try和except不能放在同一行. 
Yes: 
if foo: bar(foo) 
No: 
if foo: bar(foo) 
else: baz(foo) 
try: bar(foo) 
except ValueError: baz(foo) 
try: 
bar(foo) 
except ValueError: baz(foo)

访问控制
  在Python中, 对于琐碎又不太重要的访问函数, 你应该直接使用公有变量来取代它们, 这样可以避免额外的函数调用开销. 当添加更多功能时, 你可以用属性(property)来保持语法的一致性. 
  (译者注: 重视封装的面向对象程序员看到这个可能会很反感, 因为他们一直被教育: 所有成员变量都必须是私有的! 其实, 那真的是有点麻烦啊. 试着去接受Pythonic哲学吧) 
  另一方面, 如果访问更复杂, 或者变量的访问开销很显著, 那么你应该使用像 get_foo() 和 set_foo() 这样的函数调用. 如果之前的代码行为允许通过属性(property)访问 , 那么就不要将新的访问函数与属性绑定. 这样, 任何试图通过老方法访问变量的代码就没法运行, 使用者也就会意识到复杂性发生了变化.

命名
module_name, package_name, ClassName, method_name, ExceptionName, function_name, GLOBAL_VAR_NAME, instance_var_name, function_parameter_name, local_var_name. 
应该避免的名称 
单字符名称, 除了计数器和迭代器. 
包/模块名中的连字符(-) 
双下划线开头并结尾的名称(Python保留, 例如init)

命名约定
  所谓”内部(Internal)”表示仅模块内可用, 或者, 在类内是保护或私有的. 
  用单下划线(_)开头表示模块变量或函数是protected的(使用import * from时不会包含). 
  用双下划线(__)开头的实例变量或方法表示类内私有. 
  将相关的类和顶级函数放在同一个模块里. 不像Java, 没必要限制一个类一个模块. 
  对类名使用大写字母开头的单词(如CapWords, 即Pascal风格), 但是模块名应该用小写加下划线的方式(如lower_with_under.py). 尽管已经有很多现存的模块使用类似于CapWords.py这样的命名, 但现在已经不鼓励这样做, 因为如果模块名碰巧和类名一致, 这会让人困扰.

Python之父Guido推荐的规范
Type Public Internal 
Modules lower_with_under _lower_with_under 
Packages lower_with_under 
Classes CapWords _CapWords 
Exceptions CapWords 
Functions lower_with_under() _lower_with_under() 
Global/Class Constants CAPS_WITH_UNDER _CAPS_WITH_UNDER 
Global/Class Variables lower_with_under _lower_with_under 
Instance Variables lower_with_under _lower_with_under (protected) or __lower_with_under (private) 
Method Names lower_with_under() _lower_with_under() (protected) or __lower_with_under() (private) 
Function/Method Parameters lower_with_under 
Local Variables lower_with_under

Main

if name == ‘main‘: 
main() 
  所有的顶级代码在模块导入时都会被执行. 要小心不要去调用函数, 创建对象, 或者执行那些不应该在使用pydoc时执行的操作.

Python进阶(十一)-定义实例方法
  一个实例的私有属性就是以__开头的属性，无法被外部访问。那这些属性定义有什么用？ 
  虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。 
  实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的。

class Person(object):
    def __init__(self, name):
        self.__name = name
 
    def get_name(self):
        return self.__name

  get_name(self) 就是一个实例方法，它的第一个参数是self。init(self, name)其实也可看做是一个特殊的实例方法。 
调用实例方法必须在实例上调用：

p1 = Person('Bob')
print p1.get_name()  # self不需要显式传入
# => Bob

  在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度。

举例
  请给 Person 类增加一个私有属性 __score，表示分数，再增加一个实例方法 get_grade()，能根据 __score 的值分别返回 A-优秀, B-及格, C-不及格三档。 
注意get_grade()是实例方法，第一个参数为self。

参考代码:

class Person(object):
 
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
 
    def get_grade(self):
        if self.__score >= 80:
            return 'A'
        if self.__score >= 60:
            return 'B'
        return 'C'
 
p1 = Person('Bob', 90)
p2 = Person('Alice', 65)
p3 = Person('Tim', 48)
 
print p1.get_grade()
print p2.get_grade()
print p3.get_grade()

运行结果 

Python进阶(十二)-浅谈python中的方法
  我们在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象：

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def get_grade(self):
        return 'A'
 
p1 = Person('Bob', 90)
print p1.get_grade
# => <bound method Person.get_grade of <__main__.Person object at 0x109e58510>>
print p1.get_grade()
# => A

  也就是说，p1.get_grade 返回的是一个函数对象，但这个函数是一个绑定到实例的函数，p1.get_grade() 才是方法调用。 
因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法：

import types
def fn_get_grade(self):
    if self.score >= 80:
        return 'A'
    if self.score >= 60:
        return 'B'
    return 'C'
 
class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
 
p1 = Person('Bob', 90)
p1.get_grade = types.MethodType(fn_get_grade, p1, Person)
print p1.get_grade()
# => A
p2 = Person('Alice', 65)
print p2.get_grade()
# ERROR: AttributeError: 'Person' object has no attribute 'get_grade'
# 因为p2实例并没有绑定get_grade

  给一个实例动态添加方法并不常见，直接在class中定义要更直观。

举例
  由于属性可以是普通的值对象，如 str，int 等，也可以是方法，还可以是函数，大家看看下面代码的运行结果，请想一想 p1.get_grade 为什么是函数而不是方法：

class Person(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
        self.get_grade = lambda: 'A'
 
p1 = Person('Bob', 90)
print p1.get_grade
print p1.get_grade()

  直接把 lambda 函数赋值给 self.get_grade 和绑定方法有所不同，函数调用不需要传入 self，但是方法调用需要传入 self。

Python进阶(十三)-浅谈sorted 函数应用
  众所周知，def cmp 作为方法存在，用sort对实例进行排序时，会用到class 中的cmp。但是，在python3中，取消了 sorted对cmp的支持。 
  python3 中有关排序的sorted方法如下：

sorted(iterable，key=None,reverse=False)

  其中，key接受一个函数，这个函数只接受一个元素，默认为None。 
reverse是一个布尔值。如果设置为True，列表元素将被倒序排列，默认为False。 
  下面着重介绍key的作用原理： 
  key指定一个接收一个参数的函数，这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None 。

例1
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave','B', 10)]
sorted(students,key=lambda s: x[2]) #按照年龄来排序

  结果：[(‘dave’,’B’, 10), (‘jane’, ‘B’, 12), (‘john’, ‘A’, 15)]

例2
  这是一个字符串排序，排序规则：小写<大写<奇数<偶数 
s = ‘asdf234GDSdsf23’ #排序:小写-大写-奇数-偶数

print("".join(sorted(s, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x))))

  原理：先比较元组的第一个值，如果相等就比较元组的下一个值，以此类推。 
  先看一下Boolean value 的排序： 
  print(sorted([True,Flase]))===>结果[False,True] 
  Boolean 的排序会将 False 排在前，True排在后 .

1.x.isdigit()的作用是把数字放在前边,字母放在后边.
2.x.isdigit() and int(x) % 2 == 0的作用是保证奇数在前，偶数在后。
3.x.isupper()的作用是在前面基础上,保证字母小写在前大写在后.
4.最后的x表示在前面基础上,对所有类别数字或字母排序。
  最后结果：addffssDGS33224

例3
一道面试题：

list1=[7, -8, 5, 4, 0, -2, -5]
#要求1.正数在前负数在后 2.正数从小到大 3.负数从大到小
sorted(list1,key=lambda x:(x<0,abs(x)))

  解题思路：先按照正负排先后，再按照大小排先后。

Python进阶(十四)- 基础课程结课总结：高阶函数
  在慕课网完成了廖雪峰老师的《Python入门》与《Python进阶》两门基础课程。在此做一下简单的知识点小结。

函数式编程
  Python特点：

不是纯函数式编程（允许变量存在）；
支持高阶函数（可以传入函数作为变量）；
支持闭包（可以返回函数）；
有限度的支持匿名函数；
  高阶函数：

变量可以指向函数；
函数的参数可以接收变量；
一个函数可以接收另一个函数作为参数；
def add(x,y,f):  
    return f(x)+f(y)  
#14
add(-5,9,abs)  

内置高阶函数map()
  map函数有两个参数，一个是函数，另一个是列表，返回值为对传入的列表中每一个元素执行传入的函数操作之后得到的列表；

def format_name(s):  
    return s.title()
 
print map(format_name, ['adam', 'LISA', 'barT'])  

内置高阶函数reduce()
  reduce函数也有两个参数，一个是函数，另一个是列表，返回值为对list的每一个元素反复调用函数f，得到最终结果，以下函数为连乘；

def prod(x, y):  
    return x*y;  
 
print reduce(prod, [2, 4, 5, 7, 12])  

内置高阶函数filter()
  filter函数接受函数参数f和列表参数lst，f对lst元素进行判断，返回lst元素中调用f函数结果为true的元素组成的列表（将不满足f函数条件的元素过滤掉）；

import math  
 
def is_sqr(x):  
    return int(math.sqrt(x))*int(math.sqrt(x))==x  
 
print filter(is_sqr, range(1, 101))  

自定义排序函数sorted()
  sorted函数接受一个列表lst和一个函数参数f，f为自定义的比较lst元素大小的函数，返回值为lst中元素按f函数排列的列表；

def cmp_ignore_case(s1, s2):  
    return cmp(s1.lower(),s2.lower())  
 
print sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case)

返回函数：

def calc_prod(lst):  
    def prod(x,y):  
        return x*y;  
    def g():
        return reduce(prod,lst)  
    return g; 
 
f = calc_prod([1, 2, 3, 4])  
print f()  

闭包
  内层函数使用外层函数的参数，然后返回内层函数；

def count():  
    fs = []  
    for i in range(1, 4):  
        def f(j):  
            def g():  
              return j*j;  
            return g  
        fs.append(f(i))  
    return fs  
 
f1, f2, f3 = count()  
print f1(), f2(), f3()  

匿名函数
  传入函数参数不需要显式定义函数，可以用lambda x:statement x为参数，statement为对参数执行的语句；

def is_not_empty(s):  
    return s and len(s.strip()) > 0  
 
print filter(lambda s:s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])  

装饰器
  给函数添加新功能，并简化该函数调用；

无参数装饰器
def log(f): 
    def fn(*args, **kw): #*args，**kw保证对任意个数参数都能正常调用  
        print 'call ' + f.__name__ + '()...'  
        return f(*args, **kw)
    return fn
 
@log   #调用日志装饰器  
def factorial(n):  
    return reduce(lambda x,y: x*y, range(1, n+1))  
#call factorial()...  
#3628800  
print factorial(10)  

带参数装饰器
def log(prefix):  
    def log_decorator(f):  
        def wrapper(*args, **kw):  
            print '[%s] %s()...' % (prefix, f.__name__)  
            return f(*args, **kw)  
        return wrapper  
    return log_decorator  
 
@log('DEBUG') #DEBUG为给装饰器传入的参数  
def test():  
    pass  
#[DEBUG] test()...  
#None  
print test()  

  利用functool.wraps作用在返回的新函数上，使得调用装饰器以后不改变原函数的信息

import time, functools  
def performance(unit):  
    def perf_decorator(f):  
        @functools.wraps(f)  
        def wrapper(*args, **kw):  
            t1 = time.time()  
            r = f(*args, **kw)  
            t2 = time.time()  
            t = (t2 - t1) * 1000 if unit=='ms' else (t2 - t1)  
            print 'call %s() in %f %s' % (f.__name__, t, unit)  
            return r  
        return wrapper  
    return perf_decorator  
 
@performance('ms')  
def factorial(n):  
    return reduce(lambda x,y: x*y, range(1, n+1))  
print factorial.__name__  

偏函数
  functools.partial(f,f的默认参数) 减少需要提供给f的参数

import functools  
int2 = functools.partial(int, base=2)  
int2('1000000')  #64

Python进阶(十五)-file文件操作
  Python下文件操作与Java差不多。打开文件的模式有三种：

r，只读模式（默认）。
w，只写模式。【不可读；不存在则创建；存在则删除内容；因为会清空原有文件的内容，一定要慎用】
a，追加模式。【可读； 不存在则创建；存在则只追加内容；】
  注意最后要记得关闭文件：f.close() 
  python只能将字符串写入到文本文件。要将数值数据存储到文本本件中，必须先试用函数str()将其转换为字符串格式。

#r模式(只读模式)
f = open('yesterday',encoding='utf-8')
data = f.read()
f.close()
print(data)
#只读文件的前5行：
f = open('yesterday','r',encoding='utf-8')
for i in range(5):
    print(f.readline())
#以列表的方式读取这个文件
f = open('yesterday','r',encoding='utf-8')
for line in f.readlines():
    print(line)
#对文件的第3行，做一个特殊的打印（这种方式比较低效，因为它会先把文件全部读取到内存中，文件较大时会很影响性能）
f = open('yesterday','r',encoding='utf-8')
for index,line in enumerate(f.readlines()):
    if index == 2:
        print('-----测试线----',line)
        continue
    print(line)
#比较高效的，逐行读取文件内容，因为它是一行一行的去读取文件，不会先把文件一次性全部读取到内存中
f = open('yesterday','r',encoding='utf-8')
for line in f:
    print(line)
#比较高效的，对文件的3三行进行过特殊打印
f = open('yesterday','r',encoding='utf-8')
count = 0
for line in f:
    if count == 2:
        print('------测试线----：',line)
    count += 1
    print(line)
 
#w模式（如果没有就创建文件，如果有就清空文件，一定要慎用）
f = open('yesterday','w',encoding='utf-8')
f.write("这就是一行测试\n")
f.write("测试2\n")
f.write("测试3")
 
#a模式（追加模式，如果没有就创建文件，如果有就把内容追加进去）
f = open('yesterday','a',encoding='utf-8')
f.write("test1\n")
 
#文件光标的操作
f = open('yesterday','r',encoding='utf-8')
#获得文件的光标
print(f.tell())
print(f.readline())
print(f.tell())
#回到最开始的位置（也可以指定一个位置，前提是你得知道你去往的字符具体在哪个位置才行）
f.seek(0)
 
#显示文件的编码
print(f.encoding)
#显示文件句柄的编号（我并不确定这个说法是否正确，用到时请仔细去查一下）
print(f.fileno())
#测试是否是一个终端设备文件
print(f.isatty())
#把缓存的内容刷新到硬盘（进度条那个脚本里有写一个示例）
f.flush()
#指定文件从哪里开始截断，如果没有参数，默认从0开始等于清空了这个文件
#f.truncate()
 
#r+ 模式（读，追加模式）
f = open('yesterday','r+',encoding='utf-8')
data = f.read()
print(data)
f.write("test...\n")
 
#还有 w+写读模式， a+追加读模式，这一般不用，真用到了再去了解下吧
#rb 模式，以二进制的方式读取这个文件
#wb 模式，二进制写
'''
'''
#with语句（很实用，记得要经常用哟~，在《Python编程从入门到实战》那本书里的文件与异常那一章有详细用法）
#为了避免打开文件后忘记关闭，可以通过管理上下文，即：
with open('log','r') as f:
 
    ...
#如此方式，当with代码块执行完毕时，内部会自动关闭并释放文件资源。
#在Python 2.7 后，with又支持同时对多个文件的上下文进行管理，即：
with open('log1') as obj1, open('log2') as obj2:
    pass

参考资料
  http://www.yiibai.com/python3/file_methods.html

Python进阶(十六)-正则表达式
  正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。 
  Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。 
  在python中使用正则表达式，需要引入re模块；下面介绍下该模块中的一些方法；

compile和match
  re模块中compile用于生成pattern的对象，再通过调用pattern实例的match方法处理文本最终获得match实例；通过使用match获得信息；

import re
 
# 将正则表达式编译成Pattern对象
pattern = re.compile(r'rlovep')
# 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
m = pattern.match('rlovep.com')
if m:
# 使用Match获得分组信息
    print(m.group())
### 输出 ###
# rlovep

  re.compile(strPattern[, flag]): 
  这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。第二个参数flag是匹配模式，取值可以使用按位或运算符’|’表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile(‘pattern’, re.I | re.M)与re.compile(‘(?im)pattern’)是等价的。 
  可选值有：

re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
M(MULTILINE): 多行模式，改变’^’和’$’的行为
S(DOTALL): 点任意匹配模式，改变’.’的行为
L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
Match
  Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。 
  属性：

string: 匹配时使用的文本。
re: 匹配时使用的Pattern对象。
pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。
方法：

group([group1, …])
  获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。

groups([default]):
  以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。

groupdict([default])
返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。

start([group])
  返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。

end([group])
  返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。

span([group])
  返回(start(group), end(group))。

expand(template)
  将匹配到的分组代入template中然后返回。template中可以使用\id或\g、 \g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第10个分组，如果你想表达 \1之后是字符’0’，只能使用\g<1>0。

pattern
  Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。 
  Pattern不能直接实例化，必须使用re.compile()进行构造。 
  Pattern提供了几个可读属性用于获取表达式的相关信息：

pattern: 编译时用的表达式字符串。
flags: 编译时用的匹配模式。数字形式。
groups: 表达式中分组的数量。
groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。
实例方法[ | re模块方法]：

match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])
  这个方法将从string的pos下标处起尝试匹配pattern；如果pattern结束时仍可匹配，则返回一个Match对象；如果匹配过程中pattern无法匹配，或者匹配未结束就已到达endpos，则返回None。 
pos和endpos的默认值分别为0和len(string)；re.match()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。 
  注意：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$’。

search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])
  这个方法用于查找字符串中可以匹配成功的子串。从string的pos下标处起尝试匹配pattern，如果pattern结束时仍可匹配，则返回一个Match对象；若无法匹配，则将pos加1重新尝试匹配；直到pos=endpos时仍无法匹配则返回None。 pos和endpos的默认值分别为0和len(string))；re.search()无法指定这两个参数，参数flags用于编译pattern时指定匹配模式。

split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])
  按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。

findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])
  搜索string，以列表形式返回全部能匹配的子串。

finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])
  搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。

sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])
  使用repl替换string中每一个匹配的子串后返回替换后的字符串。 当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。 当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。 count用于指定最多替换次数，不指定时全部替换。

subn(repl, string[, count]) |re.sub(pattern, repl, string[, count])
  返回 (sub(repl, string[, count]), 替换次数)。

re.match函数
  re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。 
  函数语法： 
  re.match(pattern, string, flags=0) 
  函数参数说明： 

匹配成功re.match方法返回一个匹配的对象，否则返回None。 
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 

实例 1
#!/usr/bin/python
# -*- coding: UTF-8 -*- 
 
import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配

  以上实例运行输出结果为： 
  (0, 3) 
  None

实例 2
#!/usr/bin/python3
import re
 
line = "Cats are smarter than dogs"
 
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
 
if matchObj:
   print ("matchObj.group() : ", matchObj.group())
   print ("matchObj.group(1) : ", matchObj.group(1))
   print ("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")

  以上实例执行结果如下： 
  matchObj.group() : Cats are smarter than dogs 
  matchObj.group(1) : Cats 
  matchObj.group(2) : smarter

re.search方法
  re.search 扫描整个字符串并返回第一个成功的匹配。 
  函数语法： 
  re.search(pattern, string, flags=0) 
  函数参数说明： 

匹配成功re.search方法返回一个匹配的对象，否则返回None。 
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。 

实例一
import re
print(re.search("rlovep","rlovep.com").span())
print(re.search("com","http://rlovep.com").span())

实例二
import re
line = "This is my blog"
#匹配含有is的字符串
matchObj = re.search( r'(.*) is (.*?) .*', line, re.M|re.I)
#使用了组输出：当group不带参数是将整个匹配成功的输出
#当带参数为1时匹配的是最外层左边包括的第一个括号，一次类推；
if matchObj:
    print ("matchObj.group() : ", matchObj.group())#匹配整个
    print ("matchObj.group(1) : ", matchObj.group(1))#匹配的第一个括号
    print ("matchObj.group(2) : ", matchObj.group(2))#匹配的第二个括号
else:
    print ("No match!!")

  输出： 
  matchObj.group() : This is my blog 
  matchObj.group(1) : This 
  matchObj.group(2) : my

search和match区别
  re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

实例
#!/usr/bin/python3
 
import re
 
line = "Cats are smarter than dogs";
 
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print ("match --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")
 
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print ("search --> matchObj.group() : ", matchObj.group())
else:
   print ("No match!!")

  以上实例运行结果如下： 
  No match!! 
  search –> matchObj.group() : dogs

检索和替换
  Python 的re模块提供了re.sub用于替换字符串中的匹配项。 
  语法： 
  re.sub(pattern, repl, string, count=0) 
  参数：

pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。
string : 要被查找替换的原始字符串。
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
实例
#!/usr/bin/python3
import re
 
phone = "2004-959-559 # 这是一个电话号码"
 
# 删除注释
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)
 
# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num) 

  以上实例执行结果如下： 
  电话号码 : 2004-959-559 
  电话号码 : 2004959559 
  repl 参数是一个函数 
  以下实例中将字符串中的匹配的数字乘于 2：

#!/usr/bin/python
 
import re
 
# 将匹配的数字乘于 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

  执行输出结果为： 
  A46G8HFD1134

正则表达式修饰符 - 可选标志
  正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志： 

正则表达式模式
  模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
多数字母和数字前加一个反斜杠时会拥有不同的含义。
标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
反斜杠本身需要使用反斜杠转义。
由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r’/t’，等价于’//t’)匹配相应的特殊字符。
  下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。 

正则表达式实例
字符匹配 

参考资料
  http://www.runoob.com/python3/python3-reg-expressions.html

Python进阶(十七)-Python 字符串操作
去空格及特殊符号
s.strip().lstrip().rstrip(',')

复制字符串
#strcpy(sStr1,sStr2)
sStr1 = 'strcpy'
sStr2 = sStr1
sStr1 = 'strcpy2'
print sStr2

连接字符串
#strcat(sStr1,sStr2)
sStr1 = 'strcat'
sStr2 = 'append'
sStr1 += sStr2
print sStr1

查找字符
#strchr(sStr1,sStr2)
# < 0 为未找到
sStr1 = 'strchr'
sStr2 = 's'
nPos = sStr1.index(sStr2)
print nPos

比较字符串
#strcmp(sStr1,sStr2)
sStr1 = 'strchr'
sStr2 = 'strch'
print cmp(sStr1,sStr2)

扫描字符串是否包含指定的字符
#strspn(sStr1,sStr2)
sStr1 = '12345678'
sStr2 = '456'
#sStr1 and chars both in sStr1 and sStr2
print len(sStr1 and sStr2)

字符串长度
#strlen(sStr1)
sStr1 = 'strlen'
print len(sStr1)

将字符串中的大小写转换
#strlwr(sStr1)
sStr1 = 'JCstrlwr'
sStr1 = sStr1.upper()
#sStr1 = sStr1.lower()
print sStr1

追加指定长度的字符串
#strncat(sStr1,sStr2,n)
sStr1 = '12345'
sStr2 = 'abcdef'
n = 3
sStr1 += sStr2[0:n]
print sStr1

字符串指定长度比较
#strncmp(sStr1,sStr2,n)
sStr1 = '12345'
sStr2 = '123bc'
n = 3
print cmp(sStr1[0:n],sStr2[0:n])

复制指定长度的字符
#strncpy(sStr1,sStr2,n)
sStr1 = ''
sStr2 = '12345'
n = 3
sStr1 = sStr2[0:n]
print sStr1

将字符串前n个字符替换为指定的字符
#strnset(sStr1,ch,n)
sStr1 = '12345'
ch = 'r'
n = 3
sStr1 = n * ch + sStr1[3:]
print sStr1

扫描字符串
#strpbrk(sStr1,sStr2)
sStr1 = 'cekjgdklab'
sStr2 = 'gka'
nPos = -1
for c in sStr1:
    if c in sStr2:
        nPos = sStr1.index(c)
        break
print nPos

翻转字符串
#strrev(sStr1)
sStr1 = 'abcdefg'
sStr1 = sStr1[::-1]
print sStr1

查找字符串
#strstr(sStr1,sStr2)
sStr1 = 'abcdefg'
sStr2 = 'cde'
print sStr1.find(sStr2)

分割字符串
#strtok(sStr1,sStr2)
sStr1 = 'ab,cde,fgh,ijk'
sStr2 = ','
sStr1 = sStr1[sStr1.find(sStr2) + 1:]
print sStr1
#或者
s = 'ab,cde,fgh,ijk'
print(s.split(','))

连接字符串
delimiter = ','
mylist = ['Brazil', 'Russia', 'India', 'China']
print delimiter.join(mylist)

截取字符串
str = ’0123456789′
print str[0:3] #截取第一位到第三位的字符
print str[:] #截取字符串的全部字符
print str[6:] #截取第七个字符到结尾
print str[:-3] #截取从头开始到倒数第三个字符之前
print str[2] #截取第三个字符
print str[-1] #截取倒数第一个字符
print str[::-1] #创造一个与原字符串顺序相反的字符串
print str[-3:-1] #截取倒数第三位与倒数第一位之前的字符
print str[-3:] #截取倒数第三位到结尾
print str[:-5:-3] #逆序截取，具体啥意思没搞明白？

python字符串跟整型互转
print ("整型：",int(50))
a=int(50)
print("整型:",type(a))
numStr = "50";
print ("字符串：",type(numStr))
convertedInt = int(numStr);
print("字符串转换为整型：",convertedInt)
convertedstr=str(a)
print("整型转换为字符串:",convertedInt)
 

参考资料
  http://www.runoob.com/python3/python3-string.html

Python进阶(十八)-Python3爬虫实践
  这篇文章主要介绍了如何使用Python3爬取csdn博客访问量的相关资料,在Python2已实现的基础上实现Python3爬虫，对比版本之间的差异所在，需要的朋友可以参考下。 
  使用python来获取自己博客的访问量，也是后面将要开发项目的一部分，后边会对博客的访问量进行分析，以折线图和饼图等可视化的方式展示自己博客被访问的情况，使自己能更加清楚自己的哪些博客更受关注。其实，在较早之前博客专家本身就有这个功能，不知什么原因此功能被取消了。

一．网址分析

  进入自己的博客页面，网址为：http://blog.csdn.net/sunhuaqiang1。 网址还是比较好分析的：就是csdn的网址+个人csdn登录账号，我们来看下一页的网址。 

  看到第二页的地址为：http://blog.csdn.net/sunhuaqiang1/article/list/2后边的数字表示现在正处于第几页，再用其他的页面验证一下，确实是这样的，那么第一页为什么不是http://blog.csdn.net/sunhuaqiang1/article/list/1呢，那么我们在浏览器中输http://blog.csdn.net/sunhuaqiang1/article/list/1试试，哎，果然是第一页啊，第一页原来是被重定向了，http://blog.csdn.net/sunhuaqiang1被重定向到http://blog.csdn.net/sunhuaqiang1/article/list/1，所以两个网址都能访问第一页，那么现在规律就非常明显了： http://blog.csdn.net/sunhuaqiang1/article/list/ + 页号

二．获取标题
  右键查看网页的源代码，我们看到可以找到这样一段代码： 
 
 
  我们可以看到标题都是在标签

<span class="link_title">
<a href="/sunhuaqiang1/article/details/50651235">
...
</a>
</span>

  中的。所以我们可以使用下面的正则表达式来匹配标题：

<span class="link_title"><a href=".*?">(.*?)</a></span>

三.获取访问量
  拿到了标题之后，就要获得对应的访问量了，经过对源码的分析，我看到访问量的结构都是这样的：

<span class="link_view" title="阅读次数"><a href="/sunhuaqiang1/article/details/51289580" title="阅读次数">阅读</a>(12718)</span>

  括号中的数字即为访问量，我们可以用下面的正则表达式来匹配：

<span class="link_view".*?><a href=".*?" title="阅读次数">阅读</a>\((.*?)\)</span>

  其中，’.?’的含义是启用正则懒惰模式。必须跟在或者+后边用。 
  如：“< img src=”test.jpg” width=”60px” height=”80px”/>” 
  如果用正则匹配src中内容非懒惰模式匹配

src=".*"

  匹配结果是：src=”test.jpg” width=”60px” height=”80px” 
  意思是从=”往后匹配，直到最后一个”匹配结束 
懒惰模式正则：

src=".*?"

  结果：src=”test.jpg” 
  因为匹配到第一个”就结束了一次匹配。不会继续向后匹配。因为他懒惰嘛。

.表示除\n之外的任意字符
*表示匹配0-无穷
+表示匹配1-无穷
四.尾页判断
  接下来我们要判断当前页是否为最后一页，否则我们就不能判断什么时候结束了，我找到了源码中‘尾页’的标签，发现是下面的结构：

<a href="/sunhuaqiang1/article/list/2">下一页</a> <a href="/sunhuaqiang1/article/list/7">尾页</a>

  所以我们可以用下面的正则表达式来匹配，如果匹配成功就说明当前页不是最后一页，否则当前页就是最后一页。

<a href=".*?">尾页</a>

五.编程实现
  下面是摘自的Python2版完整的代码实现：

#!usr/bin/python
# -*- coding: utf-8 -*-
'''
Created on 2016年2月13日
@author: ***
使用python爬取csdn个人博客的访问量，主要用来练手
'''
import urllib2
import re
#当前的博客列表页号
page_num = 1
#不是最后列表的一页
notLast = 1
account = str(raw_input('输入csdn的登录账号:'))
while notLast:
    #首页地址
    baseUrl = 'http://blog.csdn.net/'+account
    #连接页号，组成爬取的页面网址
    myUrl = baseUrl+'/article/list/'+str(page_num)
    #伪装成浏览器访问，直接访问的话csdn会拒绝
    user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
    headers = {'User-Agent':user_agent}
    #构造请求
    req = urllib2.Request(myUrl,headers=headers)
    #访问页面
    myResponse = urllib2.urlopen(req)
    myPage = myResponse.read()
    #在页面中查找是否存在‘尾页'这一个标签来判断是否为最后一页
    notLast = re.findall('<a href=".*?">尾页</a>',myPage,re.S)
    print '---------------第%d页-------------' % (page_num,)
    #利用正则表达式来获取博客的标题
    title = re.findall('<span class="link_title"><a href=".*?">(.*?)</a></span>',myPage,re.S)
    titleList=[]
    for items in title:
        titleList.append(str(items).lstrip().rstrip())
    #利用正则表达式获取博客的访问量
    view = re.findall('<span class="link_view".*?><a href=".*?" title="阅读次数">阅读</a>\((.*?)\)</span>',myPage,re.S)
    viewList=[]
for items in view:
    viewList.append(str(items).lstrip().rstrip())
#将结果输出 
for n in range(len(titleList)):
    print '访问量:%s 标题:%s' % (viewList[n].zfill(4),titleList[n])
#页号加1
page_num = page_num + 1

  由于自己现在的IDE为Python3，且自己在学习Python3。故在此基础上实现Python2项目的升级改造，并在改造过程中发现版本之间的差异性。以下为Python3版本下的爬虫代码。

#!usr/bin/python
# -*- coding: utf-8 -*-
'''
Created on 2017年3月19日
@author: SUN HuaQiang
目的：使用python爬取csdn个人博客的访问量，主要用来练手Python爬虫
收获：1.了解Python爬虫的基本过程
      2.在Python2的基础上实现Python3,通过对比发现版本之间的差异
'''
import urllib.request
import urllib
import re
 
#当前的博客列表页号
page_num = 1
#初始化最后列表的页码
notLast = 1
account = str(input('请输入csdn的登录账号:'))
while notLast:
    #首页地址
    baseUrl = 'http://blog.csdn.net/' + account
    #连接页号，组成爬取的页面网址
    myUrl = baseUrl+'/article/list/' + str(page_num)
    #伪装成浏览器访问，直接访问的话csdn会拒绝
    user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
    headers = {'User-Agent':user_agent}
    #构造请求
    req = urllib.request.Request(myUrl,headers=headers)
    #访问页面
    myResponse = urllib.request.urlopen(req)
    #python3中urllib.read返回的是bytes对象，不是string,得把它转换成string对象，用bytes.decode方法
    myPage = myResponse.read().decode()
    #在页面中查找是否存在‘尾页'这一个标签来判断是否为最后一页
    notLast = re.findall('<a href=".*?">尾页</a>', myPage, re.S)
    print ('-----------第%d页--------------' % (page_num,))
    #利用正则表达式来获取博客的标题
    title = re.findall('<span class="link_title"><a href=".*?">(.*?)</a></span>',myPage,re.S)
    titleList=[]
    for items in title:
        titleList.append(str(items).lstrip().rstrip())
    #利用正则表达式获取博客的访问量
    view = re.findall('<span class="link_view".*?><a href=".*?" title="阅读次数">阅读</a>\((.*?)\)</span>',myPage,re.S)
    viewList=[]
    for items in view:
        viewList.append(str(items).lstrip().rstrip())
    #将结果输出
    for n in range(len(titleList)):
        print ('访问量:%s 标题:%s' % (viewList[n].zfill(4),titleList[n]))
    #页号加1
    page_num = page_num + 1

  下面是部分结果： 
 
  瑕疵：通过爬虫结果可以发现，在CSDN中，对于设置为指定的文章，爬取结果存在一定的问题，还包含部分css代码。 
  改善：通过更改获取博文标题的正则表达式，即可解决此问题。 
 
 
” 
  想法是好的，但是直接利用正则实现标题获取时遇到了困难，暂时并未实现理想结果。 
  遂改变思路，将利用正则获取后的字符串再进行二次正则，即替换操作，语句如下：

for items in title:
    titleList.append(re.sub('<font color="red">.*?</font>', '', str(items).lstrip().rstrip()))

  更改后的结果如下。并同时为每篇博文进行了编号。 
 
  同时，自己还希望获取到的信息包括：访问总量、积分、等级、排名、粉丝、原创、转载、译文、评论等数据信息。 
  以上信息在网页源码中如下所示。

<ul id="blog_rank"> 
    <li>访问：<span>459285次</span></li> 
    <li>积分：<span>9214</span> </li> 
    <li >等级： <span style="position:relative;display:inline-block;z-index:1" > 
    <img src="http://c.csdnimg.cn/jifen/images/xunzhang/jianzhang/blog6.png" alt="" style="vertical-align: middle;" id="leveImg"> 
    <div id="smallTittle" style=" position: absolute; left: -24px; top: 25px; text-align: center; width: 101px; height: 32px; background-color: #fff; line-height: 32px; border: 2px #DDDDDD solid; box-shadow: 0px 2px 2px rgba (0,0,0,0.1); display: none; z-index: 999;"> 
    <div style="left: 42%; top: -8px; position: absolute; width: 0; height: 0; border-left: 10px solid transparent; border-right: 10px solid transparent; border-bottom: 8px solid #EAEAEA;"></div> 
    积分：9214 </div> 
    </span> </li> 
    <li>排名：<span>第1639名</span></li> 
    </ul> 
    <ul id="blog_statistics"> 
    <li>原创：<span>425篇</span></li> 
    <li>转载：<span>44篇</span></li> 
    <li>译文：<span>2篇</span></li> 
    <li>评论：<span>108条</span></li> 
    </ul> 

  则获取访问信息的正则表达式为：

#利用正则表达式获取博客信息
sumVisit = re.findall('<li>访问：<span>(.*?)</span></li>', myPage, re.S)
credit = re.findall('<li>积分：<span>(.*?)</span> </li>', myPage, re.S)
rank = re.findall('<li>排名：<span>(.*?)</span></li>', myPage, re.S)
grade = re.findall('<li >.*?<img src=.*?/blog(.*?).png.*?>.*?</li>', test3, re.S)
original = re.findall('<li>原创：<span>(.*?)</span></li>', myPage, re.S)
reprint = re.findall('<li>转载：<span>(.*?)</span></li>', myPage, re.S)
trans = re.findall('<li>译文：<span>(.*?)</span></li>', myPage, re.S)
comment = re.findall('<li>评论：<span>(.*?)</span></li>', myPage, re.S)
 

  根据网页源码，可得出其正则表达式为

staData = re.findall('<li><a href=.*?>(.*?)</a><span>(.*?)</span></li>', myPage, re.S)
 
for i in staData:
    print(i[0] + ':' + i[1].lstrip('(').rstrip(')')+'篇')

  经过以上操作，得到的用户Blog信息如下图所示： 
 
  最终遇到的问题是：有关粉丝数的爬取遇到了问题，因为前面数据信息的获取不需要用户登录，而用户粉丝数是在用户已登录情景下获取的，故需要将用户登录信息添加进去。犯愁~ 
  PS:论文盲审送回来了，自己这段时间要用来修改论文了，后面的博客后面再说吧~

注意事项
urllib2在3.5中为urllib.request；
raw_input()在3.5中为input()；
python3中urllib.read()返回的是bytes对象，不是string,得把它转换成string对象，用bytes.decode()方法；
re.S意在使.匹配包括换行在内的所有字符；
python3对urllib和urllib2进行了重构，拆分成了urllib.request, urllib.response,urllib.parse,urllib.error等几个子模块，这样的架构从逻辑和结构上说更加合理。urljoin现在对应的函数是urllib.parse.urljoin
  注：Python2部分的爬虫代码为网络获取，在此向匿名人士表示感谢。

Python进阶(十九)-Python3安装第三方爬虫库BeautifulSoup4
  在做Python3爬虫练习时，从网上找到了一段代码如下：

#使用第三方库BeautifulSoup，用于从html或xml中提取数据
from bs4 import BeautifulSoup

  自己实践后，发现出现了错误，如下所示： 
 
  以上错误提示是说没有发现名为“bs4”的模块。即“bs4”模块未安装。 
  进入Python安装目录，以作者IDE为例， 
 
 
  控制台提示第三方库BeautifulSoup4安装成功！回到之前的程序中，会发现IntelJ已经检测到第三方库BS4的安装，已自更新项目，此时项目恢复正常，无错误提示。

常见问题
   在做BS4爬虫练习时，新建的文件名为bs4.py,结果出现如下错误提示： 
 
  即ImportError: cannot import name BeautifulSoup一般有一下几种情况： 
   1. 在python2.x下安装的BeautifulSoup在python3.x下运行会报这种错，可用pip3 install Beautifulsoup4 . 
   2. 导入时指定bs4 像这样： from bs4 import BeautifulSoup. 
   3. 太巧合，如果你测试的文件名正好命名为bs4.py,那怎么整都会报这个错，把名字改成其他的吧。

附
  BS4官方文档 

Python进阶(二十)-Python爬虫实例讲解
  本篇博文主要讲解Python爬虫实例，重点包括爬虫技术架构，组成爬虫的关键模块：URL管理器、HTML下载器和HTML解析器。

爬虫简单架构

程序入口函数(爬虫调度段)
#coding:utf8
import time, datetime
 
from maya_Spider import url_manager, html_downloader, html_parser, html_outputer
 
 
class Spider_Main(object):
    #初始化操作
    def __init__(self):
        #设置url管理器
        self.urls = url_manager.UrlManager()
        #设置HTML下载器
        self.downloader = html_downloader.HtmlDownloader()
        #设置HTML解析器
        self.parser = html_parser.HtmlParser()
        #设置HTML输出器
        self.outputer = html_outputer.HtmlOutputer()
 
    #爬虫调度程序
    def craw(self, root_url):
        count = 1
        self.urls.add_new_url(root_url)
        while self.urls.has_new_url():
            try:
                new_url = self.urls.get_new_url()
                print('craw %d : %s' % (count, new_url))
                html_content = self.downloader.download(new_url)
                new_urls, new_data = self.parser.parse(new_url, html_content)
                self.urls.add_new_urls(new_urls)
                self.outputer.collect_data(new_data)
 
                if count == 10:
                    break
 
                count = count + 1
            except:
                print('craw failed')
 
        self.outputer.output_html()
 
if __name__ == '__main__':
    #设置爬虫入口
    root_url = 'http://baike.baidu.com/view/21087.htm'
    #开始时间
    print('开始计时..............')
    start_time = datetime.datetime.now()
    obj_spider = Spider_Main()
    obj_spider.craw(root_url)
    #结束时间
    end_time = datetime.datetime.now()
    print('总用时：%ds'% (end_time - start_time).seconds)

URL管理器
class UrlManager(object):
    def __init__(self):
        self.new_urls = set()
        self.old_urls = set()
 
    def add_new_url(self, url):
        if url is None:
            return
        if url not in self.new_urls and url not in self.old_urls:
            self.new_urls.add(url)
 
    def add_new_urls(self, urls):
        if urls is None or len(urls) == 0:
            return
        for url in urls:
            self.add_new_url(url)
 
    def has_new_url(self):
        return len(self.new_urls) != 0
 
    def get_new_url(self):
        new_url = self.new_urls.pop()
        self.old_urls.add(new_url)
        return new_url

网页下载器
import urllib
import urllib.request
 
class HtmlDownloader(object):
 
    def download(self, url):
        if url is None:
            return None
 
        #伪装成浏览器访问，直接访问的话csdn会拒绝
        user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
        headers = {'User-Agent':user_agent}
        #构造请求
        req = urllib.request.Request(url,headers=headers)
        #访问页面
        response = urllib.request.urlopen(req)
        #python3中urllib.read返回的是bytes对象，不是string,得把它转换成string对象，用bytes.decode方法
        return response.read().decode()

网页解析器
import re
import urllib
from urllib.parse import urlparse
 
from bs4 import BeautifulSoup
 
class HtmlParser(object):
 
    def _get_new_urls(self, page_url, soup):
        new_urls = set()
        #/view/123.htm
        links = soup.find_all('a', href=re.compile(r'/item/.*?'))
        for link in links:
            new_url = link['href']
            new_full_url = urllib.parse.urljoin(page_url, new_url)
            new_urls.add(new_full_url)
        return new_urls
 
    #获取标题、摘要
    def _get_new_data(self, page_url, soup):
        #新建字典
        res_data = {}
        #url
        res_data['url'] = page_url
        #<dd class="lemmaWgt-lemmaTitle-title"><h1>Python</h1>获得标题标签
        title_node = soup.find('dd', class_="lemmaWgt-lemmaTitle-title").find('h1')
        print(str(title_node.get_text()))
        res_data['title'] = str(title_node.get_text())
        #<div class="lemma-summary" label-module="lemmaSummary">
        summary_node = soup.find('div', class_="lemma-summary")
        res_data['summary'] = summary_node.get_text()
 
        return res_data
 
    def parse(self, page_url, html_content):
        if page_url is None or html_content is None:
            return None
 
        soup = BeautifulSoup(html_content, 'html.parser', from_encoding='utf-8')
        new_urls = self._get_new_urls(page_url, soup)
        new_data = self._get_new_data(page_url, soup)
        return new_urls, new_data

网页输出器
class HtmlOutputer(object):
 
    def __init__(self):
        self.datas = []
 
    def collect_data(self, data):
        if data is None:
            return
        self.datas.append(data )
 
    def output_html(self):
        fout = open('maya.html', 'w', encoding='utf-8')
        fout.write("<head><meta http-equiv='content-type' content='text/html;charset=utf-8'></head>")
        fout.write('<html>')
        fout.write('<body>')
        fout.write('<table border="1">')
        # <th width="5%">Url</th>
        fout.write('''<tr style="color:red" width="90%">
                    <th>Theme</th>
                    <th width="80%">Content</th>
                    </tr>''')
        for data in self.datas:
            fout.write('<tr>\n')
            # fout.write('\t<td>%s</td>' % data['url'])
            fout.write('\t<td align="center"><a href=\'%s\'>%s</td>' % (data['url'], data['title']))
            fout.write('\t<td>%s</td>\n' % data['summary'])
            fout.write('</tr>\n')
        fout.write('</table>')
        fout.write('</body>')
        fout.write('</html>