预备知识：
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个或多个参数给可变参数
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，返回值就是该表达式的结果。
使用 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 打造上线标准的在线教育平台
注
Python进阶(一)-初识Python数据元素:列表&元组
Python不像JS或者PHP这种弱类型语言里在字符串连接时会自动转换类型，而是直接报错。要解决这个方法只有提前把int转成string，然后再拼接字符串即可。
如代码：
|
1
2
3
4
5
|
# coding=utf8
str='你的分数是:'
num=82
text=str+num+'分 | 琼台博客'
printtext
|
执行结果
直接报错：TypeError: cannot concatenate 'str' and 'int' objects
解决这个方法只有提前把num转换为字符串类型，可以使用bytes函数把int型转换为string型。
代码：
|
1
2
3
4
5
6
|
# coding=utf8
str='你的分数是:'
num=82
num=bytes(num)
text=str+num+'分 | 琼台博客'
printtext
|
结果搞定：
毕业论文已完成，下面就是等待盲审结果了。在此期间，已感觉论文无从看起。就学习一下Python吧，听说这是一门很神奇的语言。下面言归正传~
在线文档查询：点击查看
IDE：IntelJ。
有关IntelJ的安装与注册详见博文《IntelliJ IDEA 2016注册方法和注册码》。
下面介绍一下Python中几种不熟悉的数据元素：列表、元组、字典、时间。
1列表
1.1初始化列表
- 1
1.2访问列表中的值
- 1
1.3更新列表
- 1
1.4删除列表元素
- 1
1.5列表脚本操作符
列表对+和的操作符与字符串相似。+号用于组合列表，号用于重复列表，例如：
- 1
- 2
- 3
- 4
- 5
1.6列表截取
- 1
- 2
- 3
- 4
1.7列表函数&方法
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
2元组(tuple)
Python的元组与列表类似，不同之处在于元组的元素不能修改；元组使用小括号()，列表使用方括号[]；元组创建很简单，只需要在括号中添加元素，并使用逗号(,)隔开即可，
- 1
创建空元组，例如：
- 1
元组中只有一个元素时，需要在元素后面添加逗号，例如：
- 1
元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
2.1访问元组
- 1
- 2
2.2修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，例如:
- 1
- 2
- 1
- 2
- 3
- 4
- 5
2.3删除元组
元组中的元素值是不允许删除的，可以使用del语句来删除整个元组，例如:
- 1
- 2
- 3
2.4元组运算符
与字符串一样，元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
2.5元组索引&截取
- 1
- 2
- 3
- 4
2.6元组内置函数
- 1
也可如此创建字典：
- 1
- 2
每个键与值必须用冒号隔开(:)，每对用逗号分割，整体放在花括号中({})。键必须独一无二，但值则不必；值可以取任何数据类型，但必须是不可变的，如字符串，数或元组。
3.2访问字典里的值
- 1
- 2
- 3
3.3修改字典
向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对。
如下实例:
- 1
- 2
- 3
- 4
- 5
3.4删除字典
- 1
- 2
- 3
- 注意：字典不存在，del会引发一个异常
3.5字典内置函数&方法
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
4日期和时间
4.1获取当前时间
- 1
- 2
- 3
说明：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字符串转换为日期
- 1
- 2
- 3
4.2.3获取日期差
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
4.2.4获取时间差
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
注意时间是浮点数，带毫秒。
那么要获取当前时间，需要格式化一下：
- 1
- 2
- 3
4.2.5获取上个月最后一天
- 1
4.2.6字符串日期格式化为秒数
返回浮点类型
- 1
- 2
- 3
- 4
4.2.7日期格式化为秒数
返回浮点类型
- 1
- 2
- 3
4.2.8秒数转字符串
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循环判断
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
第二种：比较取巧的，先把列表用set方式去重，然后用列表的count方法
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
第三种：用reduce方式
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
通过上面的例子发现,凡是要对一个集合进行操作的，并且要有一个统计结果的，能够用循环或者递归方式解决的问题，一般情况下都可以用reduce方式实现。
Python进阶(四)-浅谈Python闭包
在函数内部定义的函数和外部定义的函数是一样的，只是他们无法被外部访问：
- 1
- 2
- 3
- 4
- 5
将 g 的定义移入函数 f 内部，防止其他代码调用 g：
- 1
- 2
- 3
- 4
- 5
但是，考察定义的 calc_sum 函数：
- 1
- 2
- 3
- 4
注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。
- 像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。
闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。举例如下：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
你可能认为调用f1()，f2()和f3()结果应该是1，4，9，但实际结果全部都是 9（请自己动手验证）。
原因就是当count()函数返回了3个函数时，这3个函数所引用的变量 i 的值已经变成了3。由于f1、f2、f3并没有被调用，所以，此时他们并未计算 i*i，当 f1 被调用时：
- 1
- 2
因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。
举例
返回闭包不能引用循环变量，请改写count()函数，让它正确返回能计算1x1、2x2、3x3的函数。
考察下面的函数 f:
- 1
- 2
- 3
- 4
它可以正确地返回一个闭包g，g所引用的变量j不是循环变量，因此将正常执行。
在count函数的循环内部，如果借助f函数，就可以避免引用循环变量i。
参考代码:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
程序实例
Python进阶(五)-浅谈python匿名函数
高阶函数可以接收函数做参数，有些时候，我们不需要显式地定义函数，直接传入匿名函数更方便。
在Python中，对匿名函数提供了有限支持。还是以map()函数为例，计算 f(x)=x2 时，除了定义一个f(x)的函数外，还可以直接传入匿名函数：
- 1
- 2
通过对比可以看出，匿名函数 lambda x: x * x 实际上就是：
- 1
- 2
- 关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。
使用匿名函数，可以不必定义函数名，直接创建一个函数对象，很多时候可以简化代码：
- 1
- 2
返回函数的时候，也可以返回匿名函数：
- 1
- 2
- 3
- 4
- 5
举例
利用匿名函数简化以下代码：
- 1
- 2
- 3
定义匿名函数时，没有return关键字，且表达式的值就是函数返回值。
参考代码:
Python进阶(六)-python编写无参数decorator
Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。
使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。
考察一个@log的定义：
- 1
- 2
- 3
- 4
- 5
对于阶乘函数，@log工作得很好：
- 1
- 2
- 3
- 4
结果：
call factorial()…
3628800
但是，对于参数不是一个的函数，调用将报错：
- 1
- 2
- 3
- 4
结果：
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，保证任意个数的参数总是能正常调用：
- 1
- 2
- 3
- 4
- 5
现在，对于任意函数，@log 都能正常工作。
举例
请编写一个@performance，它可以打印出函数调用的时间。
计算函数调用的时间可以记录调用前后的当前时间戳，然后计算两个时间戳的差。
参考代码:
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中：
- 1
在Python 3中：
- 1
reduce()函数
在Python 3里，reduce()函数已经被从全局名字空间里移除了，它现在被放置在fucntools模块里。使用时要先引入from functools import reduce
try except
try:
except Exception, e :
- 1
- 2
打开文件
原： 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编码，这就使得以下代码是合法的：
- 1
- 2
- 3
python3中替换python2中cmp函数
Python 3.4.3 的版本中已经没有cmp函数，被operator模块代替，在交互模式下使用时，需要导入模块。在没有导入模块情况下，会出现下面的错误：
提示找不到cmp函数了，那么在python3中该如何使用这个函数呢？
所以要导入模块
看下面给的内置函数
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
这几个函数就是用来替换之前的cmp，函数的返回值是布尔值。
除法
- 在python3.0中，/ 现在总是执行真除法，不管操作数的类型，都会返回包含任何余数的一个浮点结果。// 执行Floor除法，它截除掉余数并且针对整数操作数返回一个整数，如果有任何一个操作数是浮点数类型，则返回一个浮点数。
- 在python2.6中，/ 表示传统除法，如果两个操作数都是整数的话，执行截断的整数除法(好像是Floor除法？？？？)；否则，执行浮点除法(保留余数，好像是真除法？)。//执行Floor除法，并且像在python3.0中一样工作，对于整数执行截断除法，对于浮点数执行浮点除法。
Python进阶(八)-编写带参数decorator
继续考察@log 装饰器：
- 1
- 2
- 3
- 4
- 5
发现对于被装饰的函数，log打印的语句是不能变的（除了函数名）。
如果有的函数非常重要，希望打印出’[INFO] call xxx()…’，有的函数不太重要，希望打印出’[DEBUG] call xxx()…’，这时，log函数本身就需要传入’INFO’或’DEBUG’这样的参数，类似这样：
- 1
- 2
- 3
把上面的定义翻译成高阶函数的调用，就是：
- 1
上面的语句看上去还是比较绕，再展开一下：
- 1
- 2
上面的语句又相当于：
- 1
- 2
- 3
- 4
所以，带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
执行结果：
[DEBUG] test()…
None
对于这种3层嵌套的decorator定义，你可以先把它拆开：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
拆开以后会发现，调用会失败，因为在3层嵌套的decorator定义中，最内层的wrapper引用了最外层的参数prefix，所以，把一个闭包拆成普通的函数调用会比较困难。不支持闭包的编程语言要实现同样的功能就需要更多的代码。
举例
在@performance实现打印秒的同时，请给 @performace 增加一个参数，允许传入’s’或’ms’：
- 1
- 2
- 3
要实现带参数的@performance，就需要实现：
- 1
需要3层嵌套的decorator来实现。
参考代码:
Python进阶(九)-Python陷阱：Nonetype
今天解决一位网友的问题，内容如下：
请教代码问题
- 1
- 2
- 3
- 4
- 5
- 6
- 7
结果：
[1, 4, 9, 16]
None
这样写输出为什么有None
针对这一问题，自己在IDEA中进行了调试，发现果然多输出了一行None。出现这一现象确实很令人费解。
自己写了简单的测试语句，如下：
- 1
- 2
通过断点调试，内容如下：
发现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。 若代码改为如下所示，则可以完美实现列表的输出。
Python进阶(十)-Python 编程规范
在学习一门新的编程语言时，掌握其良好的编程规范可避免一些细节性错误的发生。去除一些不必要的学习障碍。
分号
不要在行尾加分号, 也不要用分号将两条命令放在同一行.
行长度
每行不超过80个字符
例外:
- 1.长的导入模块语句
- 2.注释里的URL
不要使用反斜杠连接行.
Python会将圆括号, 中括号和花括号中的行隐式连接起来 , 你可以利用这个特点. 如果需要, 你可以在表达式外围增加一对额外的圆括号.
- 1
- 2
- 3
如果一个文本字符串在一行放不下, 可以使用圆括号来实现隐式行连接:
- 1
- 2
在注释中，如果必要，将长的URL放在一行上。
Yes:
- 1
- 2
No:
- 1
- 2
- 3
注意上面例子中的元素缩进; 你可以在本文的缩进部分找到解释.
括号
宁缺毋滥的使用括号
除非是用于实现行连接, 否则不要在返回语句或条件语句中使用括号. 不过在元组两边使用括号是可以的.
Yes:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
No:
- 1
- 2
- 3
- 4
- 5
缩进
用4个空格来缩进代码
绝对不要用tab, 也不要tab和空格混用. 对于行连接的情况, 你应该要么垂直对齐换行的元素(见行长度部分的示例), 或者使用4空格的悬挂式缩进(这时第一行不应该有参数):
Yes:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
No:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
空行
顶级定义之间空两行, 方法定义之间空一行
顶级定义之间空两行, 比如函数或者类定义. 方法定义, 类定义与第一个方法之间, 都应该空一行. 函数或方法中, 某些地方要是你觉得合适, 就空一行.
空格
按照标准的排版规范来使用标点两边的空格。
括号内不要有空格.
Yes:
- 1
No:
- 1
不要在逗号, 分号, 冒号前面加空格, 但应该在它们后面加(除了在行尾).
Yes:
- 1
- 2
- 3
- 4
- 5
- 6
if x == 4 :
print x , y
x , y = y , x
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
foo = 1000 # comment
long_name = 2 # comment that should not be aligned
dictionary = {
"foo": 1,
"long_name": 2,
}
- 1
- 2
- 3
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:
列出与接口有关的所有异常.
- 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
类
类应该在其定义下有一个用于描述该类的文档字符串. 如果你的类有公共属性(Attributes), 那么文档中应该有一个属性(Attributes)段. 并且应该遵守和函数参数相同的格式.
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
块注释和行注释
最需要写注释的是代码中那些技巧性的部分. 如果你在下次代码审查的时候必须解释一下, 那么你应该现在就给它写注释. 对于复杂的操作, 应该在其操作开始前写上若干行注释. 对于不是一目了然的代码, 应在其行尾添加注释.
‘# 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.持有文件将会阻止对于文件的其他诸如移动、删除之类的操作.
- 1
而且, 幻想当文件对象析构时, 文件和sockets会自动关闭, 试图将文件对象的生命周期和文件的状态绑定在一起的想法, 都是不现实的. 因为有如下原因:
- 1.没有任何方法可以确保运行环境会真正的执行文件的析构.不同的Python实现采用不同的内存管理技术, 比如延时垃圾处理机制. 延时垃圾处理机制可能会导致对象生命周期被任意无限制的延长.
- 2.对于文件意外的引用,会导致对于文件的持有时间超出预期(比如对于异常的跟踪, 包含有全局变量等).
推荐使用 “with”语句 以管理文件:
- 1
- 2
- 3
对于不支持使用”with”语句的类似文件的对象,使用
- 1
- 2
- 3
- 4
- 5
- 6
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
即使是一个打算被用作脚本的文件, 也应该是可导入的. 并且简单的导入不应该导致这个脚本的主功能(main functionality)被执行, 这是一种副作用. 主功能应该放在一个main()函数中.
在Python中, pydoc以及单元测试要求模块必须是可导入的. 你的代码应该在执行主程序前总是检查 if name == ‘main’ , 这样当模块被导入时主程序就不会被执行.
def main():
…
if name == ‘main‘:
main()
所有的顶级代码在模块导入时都会被执行. 要小心不要去调用函数, 创建对象, 或者执行那些不应该在使用pydoc时执行的操作.
Python进阶(十一)-定义实例方法
一个实例的私有属性就是以__开头的属性，无法被外部访问。那这些属性定义有什么用？
虽然私有属性无法从外部访问，但是，从类的内部是可以访问的。除了可以定义实例的属性外，还可以定义实例的方法。
实例的方法就是在类中定义的函数，它的第一个参数永远是 self，指向调用该方法的实例本身，其他参数和一个普通函数是完全一样的。
- 1
- 2
- 3
- 4
- 5
- 6
get_name(self) 就是一个实例方法，它的第一个参数是self。init(self, name)其实也可看做是一个特殊的实例方法。
调用实例方法必须在实例上调用：
- 1
- 2
- 3
在实例方法内部，可以访问所有实例属性，这样，如果外部需要访问私有属性，可以通过方法调用获得，这种数据封装的形式除了能保护内部数据一致性外，还可以简化外部调用的难度。
举例
请给 Person 类增加一个私有属性 __score，表示分数，再增加一个实例方法 get_grade()，能根据 __score 的值分别返回 A-优秀, B-及格, C-不及格三档。
注意get_grade()是实例方法，第一个参数为self。
参考代码:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
运行结果
Python进阶(十二)-浅谈python中的方法
我们在 class 中定义的实例方法其实也是属性，它实际上是一个函数对象：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
也就是说，p1.get_grade 返回的是一个函数对象，但这个函数是一个绑定到实例的函数，p1.get_grade() 才是方法调用。
因为方法也是一个属性，所以，它也可以动态地添加到实例上，只是需要用 types.MethodType() 把一个函数变为一个方法：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
给一个实例动态添加方法并不常见，直接在class中定义要更直观。
举例
由于属性可以是普通的值对象，如 str，int 等，也可以是方法，还可以是函数，大家看看下面代码的运行结果，请想一想 p1.get_grade 为什么是函数而不是方法：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
直接把 lambda 函数赋值给 self.get_grade 和绑定方法有所不同，函数调用不需要传入 self，但是方法调用需要传入 self。
Python进阶(十三)-浅谈sorted 函数应用
众所周知，def cmp 作为方法存在，用sort对实例进行排序时，会用到class 中的cmp。但是，在python3中，取消了 sorted对cmp的支持。
python3 中有关排序的sorted方法如下：
- 1
其中，key接受一个函数，这个函数只接受一个元素，默认为None。
reverse是一个布尔值。如果设置为True，列表元素将被倒序排列，默认为False。
下面着重介绍key的作用原理：
key指定一个接收一个参数的函数，这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None 。
例1
- 1
- 2
结果：[(‘dave’,’B’, 10), (‘jane’, ‘B’, 12), (‘john’, ‘A’, 15)]
例2
这是一个字符串排序，排序规则：小写<大写<奇数<偶数
s = ‘asdf234GDSdsf23’ #排序:小写-大写-奇数-偶数
- 1
原理：先比较元组的第一个值，如果相等就比较元组的下一个值，以此类推。
先看一下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
一道面试题：
- 1
- 2
- 3
解题思路：先按照正负排先后，再按照大小排先后。
Python进阶(十四)- 基础课程结课总结：高阶函数
在慕课网完成了廖雪峰老师的《Python入门》与《Python进阶》两门基础课程。在此做一下简单的知识点小结。
函数式编程
Python特点：
- 不是纯函数式编程（允许变量存在）；
- 支持高阶函数（可以传入函数作为变量）；
- 支持闭包（可以返回函数）；
- 有限度的支持匿名函数；
高阶函数：
- 变量可以指向函数；
- 函数的参数可以接收变量；
- 一个函数可以接收另一个函数作为参数；
- 1
- 2
- 3
- 4
内置高阶函数map()
map函数有两个参数，一个是函数，另一个是列表，返回值为对传入的列表中每一个元素执行传入的函数操作之后得到的列表；
- 1
- 2
- 3
- 4
内置高阶函数reduce()
reduce函数也有两个参数，一个是函数，另一个是列表，返回值为对list的每一个元素反复调用函数f，得到最终结果，以下函数为连乘；
- 1
- 2
- 3
- 4
内置高阶函数filter()
filter函数接受函数参数f和列表参数lst，f对lst元素进行判断，返回lst元素中调用f函数结果为true的元素组成的列表（将不满足f函数条件的元素过滤掉）；
- 1
- 2
- 3
- 4
- 5
- 6
自定义排序函数sorted()
sorted函数接受一个列表lst和一个函数参数f，f为自定义的比较lst元素大小的函数，返回值为lst中元素按f函数排列的列表；
- 1
- 2
- 3
- 4
返回函数：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
闭包
内层函数使用外层函数的参数，然后返回内层函数；
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
匿名函数
传入函数参数不需要显式定义函数，可以用lambda x:statement x为参数，statement为对参数执行的语句；
- 1
- 2
- 3
- 4
装饰器
给函数添加新功能，并简化该函数调用；
无参数装饰器
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
带参数装饰器
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
利用functool.wraps作用在返回的新函数上，使得调用装饰器以后不改变原函数的信息
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
偏函数
functools.partial(f,f的默认参数) 减少需要提供给f的参数
Python进阶(十五)-file文件操作
Python下文件操作与Java差不多。打开文件的模式有三种：
- r，只读模式（默认）。
- w，只写模式。【不可读；不存在则创建；存在则删除内容；因为会清空原有文件的内容，一定要慎用】
- a，追加模式。【可读； 不存在则创建；存在则只追加内容；】
注意最后要记得关闭文件：f.close()
python只能将字符串写入到文本文件。要将数值数据存储到文本本件中，必须先试用函数str()将其转换为字符串格式。
- 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
参考资料
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获得信息；
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
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
- 1
- 2
- 3
- 4
- 5
- 6
以上实例运行输出结果为：
(0, 3)
None
实例 2
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
以上实例执行结果如下：
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() 匹配对象函数来获取匹配表达式。
实例一
- 1
- 2
- 3
实例二
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
输出：
matchObj.group() : This is my blog
matchObj.group(1) : This
matchObj.group(2) : my
search和match区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
实例
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
以上实例运行结果如下：
No match!!
search –> matchObj.group() : dogs
检索和替换
Python 的re模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0)
参数：
- pattern : 正则中的模式字符串。
- repl : 替换的字符串，也可为一个函数。
- string : 要被查找替换的原始字符串。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
实例
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
以上实例执行结果如下：
电话号码 : 2004-959-559
电话号码 : 2004959559
repl 参数是一个函数
以下实例中将字符串中的匹配的数字乘于 2：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
执行输出结果为：
A46G8HFD1134
正则表达式修饰符 - 可选标志
正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：
正则表达式模式
模式字符串使用特殊的语法来表示一个正则表达式：
- 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。
- 多数字母和数字前加一个反斜杠时会拥有不同的含义。
- 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
- 反斜杠本身需要使用反斜杠转义。
- 由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r’/t’，等价于’//t’)匹配相应的特殊字符。
下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。
正则表达式实例
字符匹配
参考资料
http://www.runoob.com/python3/python3-reg-expressions.html
Python进阶(十七)-Python 字符串操作
去空格及特殊符号
- 1
复制字符串
- 1
- 2
- 3
- 4
- 5
连接字符串
- 1
- 2
- 3
- 4
- 5
查找字符
- 1
- 2
- 3
- 4
- 5
- 6
比较字符串
- 1
- 2
- 3
- 4
扫描字符串是否包含指定的字符
- 1
- 2
- 3
- 4
- 5
字符串长度
- 1
- 2
- 3
将字符串中的大小写转换
- 1
- 2
- 3
- 4
- 5
追加指定长度的字符串
- 1
- 2
- 3
- 4
- 5
- 6
字符串指定长度比较
- 1
- 2
- 3
- 4
- 5
复制指定长度的字符
- 1
- 2
- 3
- 4
- 5
- 6
将字符串前n个字符替换为指定的字符
- 1
- 2
- 3
- 4
- 5
- 6
扫描字符串
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
翻转字符串
- 1
- 2
- 3
- 4
查找字符串
- 1
- 2
- 3
- 4
分割字符串
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
连接字符串
- 1
- 2
- 3
截取字符串
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
python字符串跟整型互转
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
参考资料
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/ +
页号
二．获取标题
右键查看网页的源代码，我们看到可以找到这样一段代码：
我们可以看到标题都是在标签
- 1
- 2
- 3
- 4
- 5
中的。所以我们可以使用下面的正则表达式来匹配标题：
- 1
三.获取访问量
拿到了标题之后，就要获得对应的访问量了，经过对源码的分析，我看到访问量的结构都是这样的：
- 1
括号中的数字即为访问量，我们可以用下面的正则表达式来匹配：
- 1
其中，’.?’的含义是启用正则懒惰模式。必须跟在或者+后边用。
如：“< img src=”test.jpg” width=”60px” height=”80px”/>”
如果用正则匹配src中内容非懒惰模式匹配
- 1
匹配结果是：src=”test.jpg” width=”60px” height=”80px”
意思是从=”往后匹配，直到最后一个”匹配结束
懒惰模式正则：
- 1
结果：src=”test.jpg”
因为匹配到第一个”就结束了一次匹配。不会继续向后匹配。因为他懒惰嘛。
- .表示除\n之外的任意字符
- *表示匹配0-无穷
- +表示匹配1-无穷
四.尾页判断
接下来我们要判断当前页是否为最后一页，否则我们就不能判断什么时候结束了，我找到了源码中‘尾页’的标签，发现是下面的结构：
- 1
所以我们可以用下面的正则表达式来匹配，如果匹配成功就说明当前页不是最后一页，否则当前页就是最后一页。
- 1
五.编程实现
下面是摘自的Python2版完整的代码实现：
- 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
由于自己现在的IDE为Python3，且自己在学习Python3。故在此基础上实现Python2项目的升级改造，并在改造过程中发现版本之间的差异性。以下为Python3版本下的爬虫代码。
- 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
下面是部分结果：
瑕疵：通过爬虫结果可以发现，在CSDN中，对于设置为指定的文章，爬取结果存在一定的问题，还包含部分css代码。
改善：通过更改获取博文标题的正则表达式，即可解决此问题。
想法是好的，但是直接利用正则实现标题获取时遇到了困难，暂时并未实现理想结果。
遂改变思路，将利用正则获取后的字符串再进行二次正则，即替换操作，语句如下：
- 1
- 2
更改后的结果如下。并同时为每篇博文进行了编号。
同时，自己还希望获取到的信息包括：访问总量、积分、等级、排名、粉丝、原创、转载、译文、评论等数据信息。
以上信息在网页源码中如下所示。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
则获取访问信息的正则表达式为：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
根据网页源码，可得出其正则表达式为
- 1
- 2
- 3
- 4
经过以上操作，得到的用户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爬虫练习时，从网上找到了一段代码如下：
- 1
- 2
自己实践后，发现出现了错误，如下所示：
以上错误提示是说没有发现名为“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,那怎么整都会报这个错，把名字改成其他的吧。
附
Python进阶(二十)-Python爬虫实例讲解
本篇博文主要讲解Python爬虫实例，重点包括爬虫技术架构，组成爬虫的关键模块：URL管理器、HTML下载器和HTML解析器。
爬虫简单架构
程序入口函数(爬虫调度段)
- 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
URL管理器
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
网页下载器
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
网页解析器
- 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
网页输出器
- 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
运行结果
附
Python进阶(二十二)-Python3使用PyMysql连接mysql数据库
python语言的3.x完全不向前兼容,导致我们在python2.x中可以正常使用的库,到了python3就用不了.比如说mysqldb。
目前MySQLdb并不支持python3.x，Python3.x连接MySQL的方案有：oursql, PyMySQL, myconnpy 等
下面来说下python3如何安装和使用pymysql，另外两个方案我会在以后再讲。
1.pymysql安装
pymysql就是作为python3环境下mysqldb的替代物,进入命令行,使用pip安装pymysql。
- 1
2.pymysql使用
如果想使用mysqldb的方式，那么直接在py文件的开头加入如下两行代码即可。
- 1
- 2
- 3
- 4
3.安装测试示例
- 1
- 2
- 3
会看到控制台输出以下信息：
说明pymysql安装成功，可正常使用。
4.pymysql操作示例
- 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
5.pymysql操作示例-银行转帐
- 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
数据库插入操作
以下实例使用执行 SQL INSERT 语句向表 EMPLOYEE 插入记录：
- 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
附 PEP 249 – Python Database API Specification v2.0文档
connect参数
connect方法
cursor方法
fetch*方法介绍
DQL
DML
事务特性
Python进阶(二十三)-Django使用pymysql连接MySQL数据库做增删改查
IDE说明
Python：3.5
Django:1.10
Pymysql:0.7.10
Mysql:5.5
注：Django1.10默认使用的是mysqlDB模块来操作数据库，而该模块已不支持Python3，所以需要其他的方式连接数据库。
本文选择使用pymysql连接组件。
前言
在学习完Python基础之后，继续学习Python Web开发方面的知识。首先决定学习Django Web开发框架。在连接数据库一块，视频教学中使用的是django内置的sqlite数据库，之前自己使用的是mysql数据库，遂决定继续使用mysql数据库。
mysql连接配置
查看了使用mysql的settings.py项目配置文件信息，如下：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
具体含义就不再解释了，一看就懂。配置好之后，在命令行项目目录下输入服务端运行命令：
- 1
却出现了错误提示，信息如下：
Django.core.exceptions. ImproperlyConfigured:Error loading MySqldb module:no module named ‘MySQLdb’.
看来，Django1.10默认使用的是mysqldb连接组件。但是，在python3.x中已经不支持那个组件了，取而代之的则是pymysql连接组件。遂决定使用pymysql连接组件。
采用上述配置方式的话默认会调用mysqlDB模块，由于Python3已经不支持该模块，所以需要修改该配置文件所在目录下的init.py文件
- 1
- 2
再次执行方式一的数据库同步命令即可。但是却出现了如下错误提示：
ImportError:cannot import name “Thing2Literal”
之所以出现以上错误，是因为MySQLdb里面有一个Thing2Literal方法，在pymysql里没有，所以导致报错。还有可能就是由于pymysql的版本低，存在这个问题，建议下载最新版本的pymysql，于是我重新下载pymysql，版本是最新的0.7.10(pip install pymysql),然后进行如下操作:
1.将settings里面的DATABASES改成MySQL相关
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
2.在settings的上一级目录中添加my.cnf 文件，内容如下：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
在项目manage.py同级目录下输入命令
- 1
- 2
至此，数据表关联成功，后面进行校验操作。
设想：Django是否可以读取已存在的数据库信息？必须得首先通过Django建立数据表吗？答案是NO，不过可以采用将Django生成的数据表保存于已存在数据库中，然后将原来的数据表明更改为“项目名称_数据表名”的形式，从而使用原有的数据表信息。
更新后的数据表信息如下：
创建超级管理员
- 1
- 2
- 3
- 4
- 5
- 6
业务逻辑层设计
接下来实现前端显示数据表信息。
业务逻辑层信息如下：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
前端显示
客户端前端显示页面信息如下:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
显示效果如下所示(有点丑)：
管理端设计
Django另外一个神奇的功能就是自带Admin管理端。而且做的还挺精致。登录Django管理界面之前，需要首先创建超管员，在DOS窗口输入命令
- 1
然后就是设置密码、邮箱等注册信息。创建好超管员身份之后，可在相应的auth_user数据表中查看信息。
其默认使用的英文，若更改为中文，只需修改settings.py在的语言设置，如下:
- 1
若要在管理端实现数据表信息的管理，只需要在admin.py中添加如下代码即可实现。真可谓言简意赅啊。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
登录管理端之后即可看到数据表中的信息。
列表项设置
其中，Blogs与Users分别对应数据库中的blog_blog与blog_user数据表。点击其中一个项目，例如点击Blogs,显示如下页面：
这就有问题了，可以看到在管理段博客列表中显示的博客列表名称均为“Blog Object”即所获取到的Blog对象。可否实现博客名称显示呢？答案是肯定的。修改一下blog中的models.py。
- 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
添加的重点就是在定义每一个类时同时定义一个python内置的序列化函数str，这样就可以实现列表项目的显示定制功能了。
点击每一个列表项可进入博文编辑页面。
单页显示条数设置
在博客列表中，发现单页显示条目为100，未免有点多，可否实现单页显示条数定制化操作呢。在admin.py中输入以下代码即可。
- 1
- 2
另外，可实现在列表显示与字段相关的其它内容。例如在博客列表中，可附加显示每篇博文的访问量等信息。
具体的操作方法是在admin.py中修改代码如下：
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
其中，list_display 就是来配置要显示的字段的，当然也可以显示非字段内容，或者字段相关的内容，list_display中的参数就是待显示的数据属性。
搜索功能
在博客列表页面需要实现搜索功能，同样需要修改admin.py文件。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
实现效果如下：
数据属性名称设置
在查看博主信息时，看到博主属性名称均为英文，可否实现别名替换？
原来在建立数据类时通过verbose_name属性即可设置别名，models.py中代码如下：
- 1
替换后的博主信息页面如下：
数据类别名设置
同时，可取数据类的别名。例如，将“User”取别名为“博主”。同样需要在models.py中相应的数据类中添加如下代码：
- 1
- 2
- 3
- 4
注：凡是涉及到管理端操作的功能均需在admin.py文件中添加即可。
在学习过程中，发觉Django的后台功能实在是太强大了，由于models模块实现了ORM框架。经过一系列操作，可以发现管理端的数据CRUD操作已经完全实现，无需用户书写任何数据库操作代码。省心省力啊！
附 Django学习资料
pymysql版本查看命令（请告知我，谢谢~）
Django基础教程
Django官网
菜鸟教程
Python进阶(二十四)-Python中函数的参数定义和可变参数
刚学用Python的时候，特别是看一些库的源码时，经常会看到func(*args, **kwargs)这样的函数定义，这个和*让人有点费解。其实只要把函数参数定义搞清楚了，就不难理解了。
先说说函数定义，我们都知道，下面的代码定义了一个函数funcA
- 1
- 2
显然，函数funcA没有参数。
下面这个函数funcB就有两个参数了，
- 1
- 2
- 3
调用的时候，我们需要使用函数名，加上圆括号扩起来的参数列表，比如 funcB(100, 99)，执行结果是：
100
99
很明显，参数的顺序和个数要和函数定义中一致，如果执行funcB(100)，Python会报错的：
TypeError: funcB() takes exactly 2 arguments (1 given)
我们可以在函数定义中使用参数默认值，比如
- 1
- 2
- 3
在函数funcC的定义中，参数b有默认值，是一个可选参数，如果我们调用funcC(100)，b会自动赋值为0。
OK，目前为止，我们要定义一个函数的时候，必须要预先定义这个函数需要多少个参数（或者说可以接受多少个参数）。一般情况下这是没问题的，但是也有在定义函数的时候，不能知道参数个数的情况（想一想C语言里的printf函数），在Python里，带*的参数就是用来接受可变数量参数的。看一个例子
- 1
- 2
- 3
- 4
- 5
调用funcD(1, 2, 3, 4, 5, 6)结果是
1
2
length of c is: 4
(3, 4, 5, 6)
我们看到，前面两个参数被a、b接受了，剩下的4个参数，全部被c接受了，c在这里是一个tuple。我们在调用funcD的时候，至少要传递2个参数，2个以上的参数，都放到c里了，如果只有两个参数，那么c就是一个empty tuple。
好了，一颗星我们弄清楚了，下面轮到两颗星。
上面的例子里，调用函数的时候，传递的参数都是根据位置来跟函数定义里的参数表匹配的，比如funcB(100, 99)和funcB(99, 100)的执行结果是不一样的。在Python里，还支持一种用关键字参数(keyword argument)调用函数的办法，也就是在调用函数的时候，明确指定参数值赋值给哪个形参。比如还是上面的funcB(a, b)，我们通过这两种方式调用
- 1
和
- 1
结果跟funcB(100, 99)都是一样的，因为我们在使用关键字参数调用的时候，指定了把100赋值给a，99赋值给b。也就是说，关键字参数可以让我们在调用函数的时候打乱参数传递的顺序！
另外，在函数调用中，可以混合使用基于位置匹配的参数和关键字参数，前题是先给出固定位置的参数，比如
def funcE(a, b, c):
print a
print b
print c
调用funcE(100, 99, 98)和调用funcE(100, c=98, b=99)的结果是一样的。
好了，经过以上铺垫，两颗星总算可以出场了：
如果一个函数定义中的最后一个形参有 ** （双星号）前缀,所有正常形参之外的其他的关键字参数都将被放置在一个字典中传递给函数，比如：
- 1
- 2
- 3
- 4
调用funcF(100, c=’你好’, b=200)，执行结果
100
c: 你好
b: 200
大家可以看到，b是一个dict对象实例，它接受了关键字参数b和c。
Python进阶(二十五)-Python读写文件
打开文件
使用open打开文件后一定要记得调用文件对象的close()方法。比如可以用try/finally语句来确保最后能关闭文件。
- 1
- 2
- 3
- 4
- 5
注：不能把open语句放在try块里，因为当打开文件出现异常时，文件对象file_object无法执行close()方法。
读文件
- 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
写文件
- 1
- 2
- 3
- 4
- 5