一、yield
def EricReadlines():
seek = 0
while True:
with open('D:/temp.txt','r') as f:
f.seek(seek)
data = f.readline()
if data:
seek = f.tell()
yield data
else:
return
for i in EricReadlines():
print i
二、三元运算及lambda表达式
result = 'gt' if 1>3 else 'lt'
print result
a = lambda x,y:x+y
print a(4,10)
三、常用内置函数
print help() #进入help命令，查看内置函数的帮助信息（直接按回车退出）
print dir()# 默认打印当前模块的所有属性，如果传一个对象参数则打印当前对象的属性
print vars()#默认打印当前模块的所有属性，如果传一个对象参数则打印当前对象的属性 dir()和vars()的区别就是：dir()只打印属性，vars()则打印属性与属性的值。
print type()#查看当前对象的数据类型
import temp
import temp
reload(temp)#reload()函数将以前导入过的模块再加载一次。重新加载（reload）包括最初导入模块时应用的分析过程和初始化过程。这样就允许在不退出解释器的情况下重新加载已更改的Python模块。
id([12])#返回对象的内存地址。
#is
------------------
cmp(2,3) #-1
cmp(2,2)
cmp(2,1)
cmp(10,1) #1 比较俩个值的大小，前者大返回1，相等返回0，后者大返回-1
abs(a) #返回绝对值
bool(a) #返回true或者false类型
divmod(a, b) #返回啊除以b的商及余数，如divmod(7, 2)返回(3, 1)
max()#返回最大值
min()#返回最小值
sum()#求和
pow(2, 11)#返回指数，2的11次方
------------------
len()#返回字符串的长度
all()#all([1,2,3,4,55,0])都为真返回true否则false
any()#any([1,2,3,4,55,0])任意一个为真返回true否则false
------------------
chr(65)#返回ASCII对应的英文字母，比如'A'
ord('A')#返回字母对应的ASCII值，比如65
hex(65) #十六进制
oct(65) #八进制
bin(65) #二进制
------------------
print range(10) #返回1-9的列表，如：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
'''
xrange直接返回的时候是一个对象，遍历的时候才生成实在的值
'''
print xrange(10)
for i in xrange(10):
print i
'''
enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。语法：enumerate(sequence, [start=0])
下面返回：
0 1
1 2
2 3
3 4
'''
for k,v in enumerate([1,2,3,4]):
print k,v
------------------
s= 'i am {0}'
print s.format('Eric') #返回 i am Eric
------------------
def Function(arg):
print arg
print apply(Function,('aaaa')) #执行函数
print map(lambda x:x+1,[1,2,3]) #map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回，例子返回：[2, 3, 4]
print filter(lambda x: x==1,[1,23,4]) #过滤出俩表中等于1的值
print reduce(lambda x,y:x+y,[1,2,3]) #累计求和，列子返回6
--------------------
x = [1, 2, 3, 4, 5]
y = [4, 5, 6]
z = [4, 5, 6]
print zip(x, y,z) #返回[(1, 4, 4), (2, 5, 5), (3, 6, 6)]
------------------
__import__()#该函数用于动态加载类和函数 。如果一个模块经常变化就可以使用 __import__() 来动态载入，如：__import__('a') # 导入 a.py 模块
hasattr()#hasattr() 函数用于判断对象是否包含对应的属性。语法：hasattr(object, name)【object -- 对象。name -- 字符串，属性名】
delattr()#delattr 函数用于删除属性。
getattr()#getattr() 函数用于返回一个对象属性值。
module = __import__('temp') #temp是自己定义的.py文件
print dir(module)
val = hasattr(module, 'version')
print val
------------------
callable() #callable() 函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。对于函数, 方法, lambda 函式, 类, 以及实现了 __call__ 方法的类实例, 它都返回 True。
compile()#compile() 函数将一个字符串编译为字节代码。
eval()#eval() 函数用来执行一个字符串表达式，并返回表达式的值
com = compile('1+1','','eval')
print eval(com)#返回2
'''exec语句 # 执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python 代码'''
code = "for i in range(0, 10): print i"
cmpcode = compile(code, '', 'exec')
exec cmpcode
code = "print 1"
cmpcode = compile(code, '', 'single')
exec cmpcode
------------------
sinstance()该函数来判断一个对象是否是一个已知的类型，类似 type()。
'''
isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。
'''
issubclass()#该方法用于判断参数 class 是否是类型参数 classinfo 的子类。
super()#函数是用于调用父类(超类)的一个方法
staticmethod() #返回函数的静态方法。
四、常用模块
1、random 用于生成随机数
import random
print random.random()
print random.randint(1,2)
print random.randrange(1,10)
#生成验证码
import random
checkcode = ''
for i in range(4):
current = random.randrange(0,4)
if current != i:
temp = chr(random.randint(65,90))
else:
temp = random.randint(0,9)
checkcode += str(temp)
print checkcode
2、md5 加密
import md5
hash = md5.new()
hash.update('admin')
print hash.hexdigest()
#推荐用这种
import hashlib
hash = hashlib.md5()
hash.update('admin')
print hash.hexdigest()
3、序列化和json
import pickle
data={'k1':123,'k2':'hello'}
#pickle.dumps 将数据通过特殊的形式转换为只有python语言认识的字符串
p_str=pickle.dumps(data)
print p_str
#pickle.dump 将数据通过特殊的形式转换为只有python语言认识的字符串,并写入文件
with open('D:/result.pk','w') as fp
pickle.dump(data,fp)
#从序列化的文件中读取数据
print pickle.load(open('D:/result.pk','r'))
-----------------------------------------------------------------------------
import json
#json.dumps 将数据通过特殊的形式转换为所有程序语言都认识的字符串
j_str=json.dumps(data)
print j_str
#json.dumps 将数据通过特殊的形式转换为所有程序语言都认识的字符串，并写入文件
with open('D:/result.pk','w') as fj
json.dump(data,fj)
4、Python 正则表达式
#re.match函数
#re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。
#语法：re.match(pattern, string, flags=0)【pattern 匹配的正则表达式，string 要匹配的字符串。flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。】
print(re.match('www', 'www.runoob.com').span()) #返回(0, 3)位置
print(re.match('www', 'www.runoob.com')).group() #返回www
print(re.match('com', 'www.runoob.com')).group() #返回None
#re.search方法
#re.search 扫描整个字符串并返回第一个成功的匹配。
#语法：
#re.search(pattern, string, flags=0)【pattern 匹配的正则表达式，string 要匹配的字符串。flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。】
print(re.search('com', 'www.runoob.com').span()) #返回(11, 14)位置
print(re.search('com', 'www.runoob.com')).group() #返回com
#re.match与re.search的区别
#re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
#re.findall函数 【注意： match 和 search 是匹配一次 findall 匹配所有。】#在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
pattern = re.compile(r'\d+') # 查找数字
print pattern.findall('runoob 123 google 456')#返回['123', '456']
'''
re.sub用于替换字符串中的匹配项。
语法：re.sub(pattern, repl, string, count=0, flags=0)【pattern : 正则中的模式字符串。
repl : 替换的字符串，也可为一个函数。string : 要被查找替换的原始字符串。count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。】
'''
#=============================================================================================================================================================
'''
正则表达式模式：
^ 匹配字符串的开头
$ 匹配字符串的末尾。
. 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。
[...] 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。
re* 匹配0个或多个的表达式。
re+ 匹配1个或多个的表达式。
re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n} 精确匹配 n 个前面表达式。例如， o{2} 不能匹配 "Bob" 中的 "o"，但是能匹配 "food" 中的两个 o。
re{ n,} 匹配 n 个前面表达式。例如， o{2,} 不能匹配"Bob"中的"o"，但能匹配 "foooood"中的所有 o。"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a| b 匹配a或b
(re) 匹配括号内的表达式，也表示一个组
(?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。
(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。
(?: re) 类似 (...), 但是不表示一个组
(?imx: re) 在括号中使用i, m, 或 x 可选标志
(?-imx: re) 在括号中不使用i, m, 或 x 可选标志
(?#...) 注释.
(?= re) 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。
(?! re) 前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re) 匹配的独立模式，省去回溯。
\w 匹配字母数字及下划线
\W 匹配非字母数字及下划线
\s 匹配任意空白字符，等价于 [\t\n\r\f].
\S 匹配任意非空字符
\d 匹配任意数字，等价于 [0-9].
\D 匹配任意非数字
\A 匹配字符串开始
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。
\z 匹配字符串结束
\G 匹配最后匹配完成的位置。
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。
\B 匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。
\n, \t, 等. 匹配一个换行符。匹配一个制表符。等
\1...\9 匹配第n个分组的内容。
\10 匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。
-----------------------------------------------------------------------------------------------------------------------------------------
实例：
[Pp]ython 匹配 "Python" 或 "python"
rub[ye] 匹配 "ruby" 或 "rube"
[aeiou] 匹配中括号内的任意一个字母
[0-9] 匹配任何数字。类似于 [0123456789]
[a-z] 匹配任何小写字母
[A-Z] 匹配任何大写字母
[a-zA-Z0-9] 匹配任何字母及数字
[^aeiou] 除了aeiou字母以外的所有字符
[^0-9] 匹配除了数字外的字符
. 匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。
\d 匹配一个数字字符。等价于 [0-9]。
\D 匹配一个非数字字符。等价于 [^0-9]。
\s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。
\S 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。
'''
5、sys
sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.maxint 最大的Int值
sys.maxunicode 最大的Unicode值
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称
sys.stdout.write('please:')
val = sys.stdin.readline()[:-1]
print val
6、os
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
os.curdir 返回当前目录: ('.')
os.pardir 获取当前目录的父目录字符串名：('..')
os.makedirs('dirname1/dirname2') 可生成多层递归目录
os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() 删除一个文件
os.rename("oldname","newname") 重命名文件/目录
os.stat('path/filename') 获取文件/目录信息
os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep 输出用于分割文件路径的字符串
os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command") 运行shell命令，直接显示
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成目录和文件名二元组返回
os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path) 如果path是绝对路径，返回True
os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
7、Python的时间模块
import time
print time.time()#/(60*60*24*365) 时间戳 1970年1月1日之后的秒
print time.mktime(time.localtime()) #时间戳 1970年1月1日之后的秒
print time.gmtime() # 函数将一个时间戳转换为UTC时区（0时区）的struct_time，可选的参数sec表示从1970-1-1以来的秒数
print time.localtime() # 函数类似gmtime()，作用是格式化时间戳为本地的时间。 如果sec参数未输入，则以当前时间为转换标准。
print time.strptime('2014-11-11', '%Y-%m-%d') #函数根据指定的格式把一个时间字符串解析为时间元组。
print time.strftime('%Y-%m-%d') #默认返回当前时间
print time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()) #默认返回当前时间
print time.asctime() #asctime() 函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。默认当前时间
print time.asctime(time.localtime())#asctime() 函数接受时间元组并返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符串。默认当前时间
print time.ctime(time.time())#ctime() 函数把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。 如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于 asctime(localtime(secs))。
import datetime
'''
datetime.date：表示日期的类。常用的属性有year, month, day
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond
datetime.datetime：表示日期时间
datetime.timedelta：表示时间间隔，即两个时间点之间的长度
timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])
strftime("%Y-%m-%d")
'''
import datetime
print datetime.datetime.now()#当前的时间
print datetime.datetime.now() - datetime.timedelta(days=5)#往前推五天
8、装饰器（下面是自己总结的装饰器）
#!/usr/bin/env python
#coding:utf-8
#函数前添加
def Before(*args):
print 'before'
#函数后添加
def After(*args):
print 'after'
#通用装饰器方法
def Filter(before_func,after_func):
def outer(main_func):
def wrapper(*args):
before_result = before_func(*args)
if(before_result != None):
return before_result;
main_result = main_func(*args)
if(main_result != None):
return main_result;
after_result = after_func(*args)
if(after_result != None):
return after_result;
return wrapper
return outer
#函数体
@Filter(Before, After)
def Index(request,kargs):
print 'index'
@Filter(Before, After)
def login():
print 'login'
return '返回成功'
#入口
if __name__ == '__main__':
Index(1,2)
print '==============================================='
login()
五、异常处理
捕捉异常可以使用try/except语句。
try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。
如果你不想在异常发生时结束你的程序，只需在try里捕获它。
语法：
以下为简单的try....except...else的语法：
try:
<语句> #运行别的代码
except <名字>：
<语句> #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句> #如果引发了'name'异常，获得附加的数据
else:
<语句> #如果没有异常发生
try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。
如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印缺省的出错信息）。
如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。
实例：下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，且并未发生异常：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print "Error: 没有找到文件或读取文件失败"
else:
print "内容写入文件成功"
fh.close()
实例
下面是简单的例子，它打开一个文件，在该文件中的内容写入内容，但文件没有写入权限，发生了异常：
#!/usr/bin/python
# -*- coding: UTF-8 -*-
try:
fh = open("testfile", "w")
fh.write("这是一个测试文件，用于测试异常!!")
except IOError:
print "Error: 没有找到文件或读取文件失败"
else:
print "内容写入文件成功"
fh.close()