函数                                       说明
sub(pattern,repl,string)    把字符串中的所有匹配表达式pattern中的地方替换成repl
[^**]                           表示不匹配此字符集中的任何一个字符
\u4e00-\u9fa5                   汉字的unicode范围
\u0030-\u0039                   数字的unicode范围
\u0041-\u005a                   大写字母unicode范围
\u0061-\u007a                  小写字母unicode范围
\uAC00-\uD7AF             韩文的unicode范围
\u3040-\u31FF                日文的unicode范围

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Date    : 2019-06-03 10:12:06
# @Author  : XuYG (xiaoxu04@foxmail.com)
# @Link    : http://www.itecfun.com
# @Version : $V1.0$

import os
from PIL import Image
import pytesseract

class xygORC(object):
	def __init__(self,dir_path,lang,file_name,write_mode):
		'''
		初始化相关参数
		
		Arguments:
			dir_path {[str]} -- [要识别的图片所在目录]
			lang {[str]} -- [tessdata训练数据包的名称，默认采用简体中文识别 chi_sim]
			file_name {[str]} -- [识别的文本保存的文件名称，可自由命名]
			write_mode {[str]} -- [default a+]
		'''
		self.dir_path = dir_path
		self.lang = lang
		self.file_name = file_name
		self.write_mode = write_mode
		self.content = ""

	def recognize(self,image_path,lang):
		'''
		单张图片识别	
		Arguments:
			image_path {[str]} -- [待识别图片路径]
			lang {[str]} -- [tessdata 训练数据包的名称，简体中文用chi_sim进行识别]
		Returns:
			[str] -- [返回识别的本张图片的文字内容]
		'''
		image = Image.open(image_path)
		#使用tessdata chi_sim简体中文训练数据进行识别
		content = pytesseract.image_to_string(image, lang=lang)
		return content
	def save(self,file_name,content,write_mode):
		'''
		保存识别的内容
		Arguments:
			file_name {[str]} -- [保存的文件路径]
			content {[str]} -- [文本内容]
			write_mode {[str]} -- [a,b,r,a+,b+...]
		Returns:
			bool -- [返回保存状态，True or False]
		'''
		#结果保存
		with open(file_name,write_mode) as f:
			f.write(content.replace(' ',''))  #识别后每个字之间有空格，需要去掉空格
			return True
		return False

	def recognize_all(self,dir_path,lang):
		'''
		识别制定目录下所有图片中的文字
		
		Arguments:
			dir_path {[str]} -- [目录路径]
			lang {[str]} -- [tessdata 训练数据包的名称，简体中文用chi_sim进行识别]
		
		Returns:
			[str] -- [目录下所有图片识别后的文字内容]
		'''
		img_list = self.get_file_list(dir_path, [])
		img_list.sort(key=lambda x: os.path.getmtime(x))
		content = ""
		for img in img_list:
			text = self.recognize(img, lang)
			content +=text +"\n "
			print("'{0}'已识别完成！".format(img))
		return content

	def get_file_list(self,dir, file_list):
		'''
		获取指定目录下所有待识别的jpg、png图片列表
		并按时间排序后返回
		
		Arguments:
			dir {[str]} -- [图片存放目录]
			file_list {[list]} -- [图片列表]
		
		Returns:
			[list] -- [目录下所有图片列表]
		'''
		newDir = dir
		if os.path.isfile(dir):
			ext = os.path.splitext(dir)[-1]
			if ext == ".jpg" or ext ==".png":
				file_list.append(dir)
		elif os.path.isdir(dir):
			for file in os.listdir(dir):
				newDir = os.path.join(dir, file)
				self.get_file_list(newDir, file_list)
		return file_list

	def main(self):
		'''
		主函数入口
		'''
		self.content = self.recognize_all(self.dir_path, self.lang)
		self.save(self.file_name, self.content, write_mode)


if __name__ == '__main__':
	dir_path ='E:\\国家政策\\政策学习01：国家大数据战略与社会治理革命' 
	lang  ='chi_sim'  #tessdata chi_sim训练数据包的名称
	file_name = "政策学习.txt" #要保存的识别文字的文件名称，可自由命名
	write_mode ="a+" #以文件末尾追加的形式进行写入
	os.chdir(dir_path) ##将工作目录切换到图片所在目录，主要目的是将文件保存在图片所在目录，方便查阅

	myorc = xygORC(dir_path,lang,file_name,write_mode)

	myorc.main()

pip install beaufifulsoup4

安装BeautifulSoup4 失败，主要是bs4是用python2.7编写的，需使用自带工具2to3.py工具转变下代码即可。

首先，下载BeautifulSoup对相应的版本。

将beaufifulsoup4-4.6.0.tar.gz解压缩，拷贝目录下的bs4文件到 python安装目录的Lib文件夹下

cmd进入 python安装目录的Tools\scripts中

在命令行中输入：python 2to3.py  -w "D:\Program Files\Python\Python36\Lib\bs4"

进入python，输入 import bs4看下是否正常~。

响应时间
提前响应
ttk treeview的TreeviewSelect事件是提前的，即你选中了某行，通过treeview.selection()[0]得到的就是这一样。

延后相应
比如ttk的treeview是的单击的情况，单击的行被选中了，但是通过 treeview.selection()[0]得到的却不是选中的行！而是之前选中的行。可以参考下这里。

响应函数
event_handler(event,*args)

event参数
event 参数有以下属性：

['__doc__', '__module__', 'char', 'delta', 'height', 'keycode', 'keysym', 'keysym_num', 'num', 'send_event', 'serial', 'state', 'time', 'type', 'widget', 'width', 'x', 'x_root', 'y', 'y_root']

Event Attributes
widget
The widget which generated this event. This is a valid Tkinter widget instance, not a name. This attribute is set for all events.

x, y
鼠标当前的相对位置，以像素为单位。

比如，ttk treeview 有个通过y坐标定位行的方法：identify_row(self, y)

x_root, y_root
鼠标当前的绝对位置（相对于设备的左上角）。以像素为单位。

char
字符（键盘事件中才有）， 类型是字符串。

keysym
The key symbol (keyboard events only).

键符（键盘事件中才有）

keycode
键码 (键盘事件中才有).

num
按钮号码（鼠标事件中才有）1-左键/2-中/3-右

width, height
widget的新尺寸，以像素为单位(Configure events only).

type
        事件类型
        1---
        2---
        3---
        4---鼠标
更多资料参考这里。
绑定事件
控件.bind('<事件代码>',event_handler)
适用于大多数控件。此外还有bind_all方法。

控件.protocal('事件代码', event_handler)
这种情况的控件，必需是顶层窗口或者root容器。

df.to_excel('D:\\dataframe_excel.xls',index=True)  #export to excel file

#写入excel文件需要安装 xlwt 模块 pip install xlwt
import xlwt
ModuleNotFoundError: No module named 'xlwt'

dfexcel = pd.read_excel('D:\\dataframe_excel.xls')

#读取excel文件需要安装 xlrd 模块 pip install xlrd
import xlrd
ModuleNotFoundError: No module named 'xlrd'

2. 主要开发Web相关的的话可以用PyCharm或者Aptana Studio 3；

3. 作为适应了matlab用户界面的我来说我还是使用了PyScripter，一个主动性高的IDE和一个开放性高的python相遇就是一件美好的事情。

单从界面来说其实我们都可以看见许多经典的操作界面的影子，比如visual studio，matlab, wordpad等等。

主要有以下原因:

1. Python是解释语言，程序写起来非常方便

写程序方便对做机器学习的人很重要。
因为经常需要对模型进行各种各样的修改，这在编译语言里很可能是牵一发而动全身的事情，Python里通常可以用很少的时间实现。

举例来说，在C等编译语言里写一个矩阵乘法，需要自己分配操作数（矩阵）的内存、分配结果的内存、手动对BLAS接口调用gemm、最后如果没用smart pointer还得手动回收内存空间。Python几乎就是import numpy; numpy.dot两句话的事。

当然现在很多面向C/C++库已经支持托管的内存管理了，这也让开发过程容易了很多，但解释语言仍然有天生的优势——不需要编译时间。这对机器学习这种需要大量prototyping和迭代的研究方向是非常有益工作效率的。
2. Python的开发生态成熟，有很多有用的库可以用

除了上面说到的NumPy，还有SciPy、NLTK、os（自带）等等不一而足。Python灵活的语法还使得包括文本操作、list/dict comprehension等非常实用的功能非常容易高效实现（编写和运行效率都高），配合lambda等使用更是方便。这也是Python良性生态背后的一大原因。相比而言，Lua虽然也是解释语言，甚至有LuaJIT这种神器加持，但其本身很难做到Python这样，一是因为有Python这个前辈占领着市场份额，另一个也因为它本身种种反常识的设计（比如全局变量）。不过借着Lua-Python bridge和Torch的东风，Lua似乎也在寄生兴起。
3. Python的效率很高。

解释语言的发展已经大大超过许多人的想象。很多比如list comprehension的语法糖都是贴近内核实现的。除了JIT[1]之外，还有Cython可以大幅增加运行效率。最后，得益于Python对C的接口，很多像gnumpy, theano这样高效、Python接口友好的库可以加速程序的运行，在强大团队的支撑下，这些库的效率可能比一个不熟练的程序员用C写一个月调优的效率还要高。
4.数据存储方便

有sql,hadoop,mangodb,redis,spark等
5.数据获取方便

有Scrapy,beautifulsoup,requests,paramiko等
6.数据运算方便

有pandas，Numpy，scipy等
7.输出结果方便

有matplotlib,VisPy等
8.和其他语言交互方便

有ctypes,rpy2,Cython,SWIG,PyQt,boost.python
9.加速方便

有pypy,Cython,PyCUDA

10.图形图像方便

有PyOpenGL,PyOpenCV,mayavi2
11.信号处理方便

PyWavelets，scipy.signal
12.云系统支持方便

github,sourceforge,EC2,BAT,HPC
13.python开源

python支持的平台多，包括windows,linux,unix,macos。而matlab太贵，只能调用其api，用python省钱，省钱就是赚钱。
python 和 c++ 做个比较。

c++ 的cpu效率是远远高于 python 的.不过 python 是一门胶水语言，它可以和任何语言结合，基于这个优点，很多数据处理的python 库底层都是 c++ 实现的，意思就是说：你用python写code，但效率是c++的。只有那些for 循环，还是用python的效率高。

近年来机器学习最要是深度学习，而深度学习使用cuda gpu加速远比cpu要快，而cuda 是c++写的。
所以现在TensorLayer、theano 等深度学习库都是 python 编程、底层c++。

版权声明：本文为博主原创文章，未经博主允许不得转载。

注意个软件版本需要相适应

已配置成功的软件环境如下：
Apache:httpd-2.4.20-x86-r2-VC9
Python:2.7.9 win32
Django:1.9.6
mod_wsgi:mod_wsgi-4.4.23+ap24vc9-cp27-cp27m-win32

字符串或串(String)是由数字、字母、下划线组成的一串字符。一般记为 s=“a1a2···an”(n>=0)。它是编程语言中表示文本的数据类型。 通常以串的整体作为操作对象，如：在串中查找某个子串、求取一个子串、在串的某个位置上插入一个子串以及删除一个子串等。两个字符串相等的充要条件是：长度相等，并且各个对应位置上的字符都相等。
python 字符串相关特性
1 属于python基本数据类型和结构的一种。2 本身是不可变的数据类型。 3 有很多内置的方法
字符串连接
方法1： 用字符串的join方法
a = ['a','b','c','d']
content = ''
content = ''.join(a)
print content
方法2： 用字符串的替换占位符替换
a = ['a','b','c','d']
content = ''
content = '%s%s%s%s' % tuple(a)
print content
想要了解更多,请看python字符串连接
字符串截取
我们可以通过索引来提取想要获取的字符，可以把python的字符串也做为字符串的列表就更好理解

python的字串列表有2种取值顺序
1是从左到右索引默认0开始的，最大范围是字符串长度少1
s = 'ilovepython'
s[0]的结果是i

2是从右到左索引默认-1开始的，最大范围是字符串开头
s = 'ilovepython'
s[-1]的结果是n

上面这个是取得一个字符，如果你的实际要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

比如
s = 'ilovepython'
s[1:5]的结果是love
当使用以冒号分隔的字符串，python返回一个新的对象，结果包含了以这对偏移标识的连续的内容，左边的开始是包含了下边界，比如
上面的结果包含了s[1]的值l，而取到的最大范围不包括上边界，就是s[5]的值p

想要了解更多,请看python字符串截取
字符串替换
字符串替换可以用内置的方法和正则表达式完成。
1用字符串本身的replace方法:
a = 'hello word'
b = a.replace('word','python')
print b
2用正则表达式来完成替换:
import re
a = 'hello word'
strinfo = re.compile('word')
b = strinfo.sub('python',a)
print b
想要了解更多,请看python 字符串替换
字符串比较
cmp方法比较两个对象，并根据结果返回一个整数。cmp(x,y)如果X< Y,返回值是负数 如果X>Y 返回的值为正数。
sStr1 = 'strch'
sStr2 = 'strchr'
print cmp(sStr1,sStr2)##-1
字符串相加
我们通过操作符号+来进行字符串的相加，不过建议还是用其他的方式来进行字符串的拼接，这样效率高点。
原因：在循环连接字符串的时候，他每次连接一次，就要重新开辟空间，然后把字符串连接起来，再放入新的空间，再一次循环，又要开辟新的空间，把字符串连接起来放入新的空间，如此反复，内存操作比较频繁，每次都要计算内存空间，然后开辟内存空间，再释放内存空间，效率非常低。
sStr1 = 'strch'
sStr2 = 'strchr'
newstr = sStr1 + sStr2
print newstr
字符串查找
python 字符串查找有4个方法，1 find,2 index方法，3 rfind方法,4 rindex方法。
1 find()方法：
info = 'abca'
print info.find('a')##从下标0开始，查找在字符串里第一个出现的子串，返回结果：0

info = 'abca'
print info.find('a',1)##从下标1开始，查找在字符串里第一个出现的子串：返回结果3

info = 'abca'
print info.find('333')##返回-1,查找不到返回-1
2 index()方法：
python 的index方法是在字符串里查找子串第一次出现的位置，类似字符串的find方法，不过比find方法更好的是，如果查找不到子串，会抛出异常，而不是返回-1
info = 'abca'
print info.index('a')
print info.index('33')
字符串分割
字符串分割，可以用split,rsplit方法，通过相应的规则来切割成生成列表对象
info = 'name:haha,age:20$name:python,age:30$name:fef,age:55'
content = info.split('$')
print content
字符串翻转
通过步进反转[::-1]
a = 'abcd'
b = a[::-1]##[::-1]通过步进反转
print b
字符串编码
通过字符串的decode和encode方法
1 encode([encoding,[errors]])
#其中encoding可以有多种值，比如gb2312 gbk gb18030 bz2 zlib big5 bzse64等都支持。errors默认值为"strict"，意思是UnicodeError。可能的值还有'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 和所有的通过codecs.register_error注册的值。
S.decode([encoding,[errors]]) 下面是字符串编码应用:
a = '你好'
b = 'python'
print a.decode('utf-8').encode('gbk')##decode方法把字符串转换为unicode对象，然后通过encode方法转换为指定的编码字符串对象
print b.decode('utf-8')##decode方法把字符串转换为unicode对象
字符串追加和拼接
通过字符串的占位符来进行字符串的拼接
#1 元组拼接
m = 'python'
astr = 'i love %s' % m
print astr

#2 字符串的format方法
m = 'python'
astr = "i love {python}".format(python=m)
print astr

#3 字典格式化字符串
m = 'python'
astr = "i love %(python)s " % {'python':m}
print astr
字符串复制
通过变量来进行赋值
fstr = 'strcpy'
sstr = fstr
fstr = 'strcpy2'
print sstr
字符串长度
通过内置方法len()来计算字符串的长度，注意这个计算的是字符的长度。
aa = 'afebb'
bb = '你'
print len(aa)
print len(bb)
字符串大小写
通过下面的upper(),lower()等方法来转换大小写
S.upper()#S中的字母大写
S.lower() #S中的字母小写
S.capitalize() #首字母大写
S.istitle() #S是否是首字母大写的
S.isupper() #S中的字母是否便是大写
S.islower() #S中的字母是否全是小写
字符串去空格
通过strip(),lstrip(),rstrip()方法去除字符串的空格
S.strip()去掉字符串的左右空格
S.lstrip()去掉字符串的左边空格
S.rstrip()去掉字符串的右边空格
字符串其他方法
字符串相关的其他方法:count(),join()方法等。
S.center(width, [fillchar]) #中间对齐
S.count(substr, [start, [end]]) #计算substr在S中出现的次数
S.expandtabs([tabsize]) #把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个
S.isalnum() #是否全是字母和数字，并至少有一个字符
S.isalpha() #是否全是字母，并至少有一个字符
S.isspace() #是否全是空白字符，并至少有一个字符
S.join()#S中的join，把列表生成一个字符串对象
S.ljust(width,[fillchar]) #输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格。
S.rjust(width,[fillchar]) #右对齐
S.splitlines([keepends]) #把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
S.swapcase() #大小写互换

得到当前工作目录，即当前Python脚本工作的目录路径: os.getcwd()

返回指定目录下的所有文件和目录名:os.listdir()

函数用来删除一个文件:os.remove()

删除多个目录：os.removedirs（r“c：python”）

检验给出的路径是否是一个文件：os.path.isfile()

检验给出的路径是否是一个目录：os.path.isdir()

判断是否是绝对路径：os.path.isabs()

检验给出的路径是否真地存:os.path.exists()

返回一个路径的目录名和文件名:os.path.split()     eg os.path.split('/home/swaroop/byte/code/poem.txt') 结果：('/home/swaroop/byte/code', 'poem.txt')

分离扩展名：os.path.splitext()

获取路径名：os.path.dirname()

获取文件名：os.path.basename()

运行shell命令: os.system()

读取和设置环境变量:os.getenv() 与os.putenv()

给出当前平台使用的行终止符:os.linesep    Windows使用'\r\n'，Linux使用'\n'而Mac使用'\r'

指示你正在使用的平台：os.name       对于Windows，它是'nt'，而对于Linux/Unix用户，它是'posix'

重命名：os.rename（old， new）

创建多级目录：os.makedirs（r“c：python\test”）

创建单个目录：os.mkdir（“test”）

获取文件属性：os.stat（file）

修改文件权限与时间戳：os.chmod（file）

终止当前进程：os.exit（）

获取文件大小：os.path.getsize（filename）

文件操作：
os.mknod("test.txt")        创建空文件
fp = open("test.txt",w)     直接打开一个文件，如果文件不存在则创建文件

关于open 模式：

w     以写方式打开，
a     以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+     以读写模式打开
w+     以读写模式打开 (参见 w )
a+     以读写模式打开 (参见 a )
rb     以二进制读模式打开
wb     以二进制写模式打开 (参见 w )
ab     以二进制追加模式打开 (参见 a )
rb+    以二进制读写模式打开 (参见 r+ )
wb+    以二进制读写模式打开 (参见 w+ )
ab+    以二进制读写模式打开 (参见 a+ )

fp.read([size])                     #size为读取的长度，以byte为单位

fp.readline([size])                 #读一行，如果定义了size，有可能返回的只是一行的一部分

fp.readlines([size])                #把文件每一行作为一个list的一个成员，并返回这个list。其实它的内部是通过循环调用readline()来实现的。如果提供size参数，size是表示读取内容的总长，也就是说可能只读到文件的一部分。

fp.write(str)                      #把str写到文件中，write()并不会在str后加上一个换行符

fp.writelines(seq)            #把seq的内容全部写到文件中(多行一次性写入)。这个函数也只是忠实地写入，不会在每行后面加上任何东西。

fp.close()                        #关闭文件。python会在一个文件不用后自动关闭文件，不过这一功能没有保证，最好还是养成自己关闭的习惯。  如果一个文件在关闭后还对其进行操作会产生ValueError

fp.flush()                                      #把缓冲区的内容写入硬盘

fp.fileno()                                      #返回一个长整型的”文件标签“

fp.isatty()                                      #文件是否是一个终端设备文件（unix系统中的）

fp.tell()                                         #返回文件操作标记的当前位置，以文件的开头为原点

fp.next()                                       #返回下一行，并将文件操作标记位移到下一行。把一个file用于for … in file这样的语句时，就是调用next()函数来实现遍历的。

fp.seek(offset[,whence])              #将文件打操作标记移到offset的位置。这个offset一般是相对于文件的开头来计算的，一般为正数。但如果提供了whence参数就不一定了，whence可以为0表示从头开始计算，1表示以当前位置为原点计算。2表示以文件末尾为原点进行计算。需要注意，如果文件以a或a+的模式打开，每次进行写操作时，文件操作标记会自动返回到文件末尾。

fp.truncate([size])                       #把文件裁成规定的大小，默认的是裁到当前文件操作标记的位置。如果size比文件的大小还要大，依据系统的不同可能是不改变文件，也可能是用0把文件补到相应的大小，也可能是以一些随机的内容加上去。

目录操作：
os.mkdir("file")                   创建目录
复制文件：
shutil.copyfile("oldfile","newfile")       oldfile和newfile都只能是文件
shutil.copy("oldfile","newfile")            oldfile只能是文件夹，newfile可以是文件，也可以是目标目录
复制文件夹：
shutil.copytree("olddir","newdir")        olddir和newdir都只能是目录，且newdir必须不存在
重命名文件（目录）
os.rename("oldname","newname")       文件或目录都是使用这条命令
移动文件（目录）
shutil.move("oldpos","newpos")   
删除文件
os.remove("file")
删除目录
os.rmdir("dir")只能删除空目录
shutil.rmtree("dir")    空目录、有内容的目录都可以删
转换目录
os.chdir("path")   换路径

相关例子

1 将文件夹下所有图片名称加上'_fc'

python代码:

# -*- coding:utf-8 -*-
import re
import os
import time
#str.split(string)分割字符串
#'连接符'.join(list) 将列表组成字符串
def change_name(path):
    global i
    if not os.path.isdir(path) and not os.path.isfile(path):
        return False
    if os.path.isfile(path):
        file_path = os.path.split(path) #分割出目录与文件
        lists = file_path[1].split('.') #分割出文件与文件扩展名
        file_ext = lists[-1] #取出后缀名(列表切片操作)
        img_ext = ['bmp','jpeg','gif','psd','png','jpg']
        if file_ext in img_ext:
            os.rename(path,file_path[0]+'/'+lists[0]+'_fc.'+file_ext)
            i+=1 #注意这里的i是一个陷阱
        #或者
        #img_ext = 'bmp|jpeg|gif|psd|png|jpg'
        #if file_ext in img_ext:
        #    print('ok---'+file_ext)
    elif os.path.isdir(path):
        for x in os.listdir(path):
            change_name(os.path.join(path,x)) #os.path.join()在路径处理上很有用

img_dir = 'D:\\xx\\xx\\images'
img_dir = img_dir.replace('\\','/')
start = time.time()
i = 0
change_name(img_dir)
c = time.time() - start
print('程序运行耗时:%0.2f'%(c))
print('总共处理了 %s 张图片'%(i))
输出结果：

程序运行耗时:0.11
总共处理了 109 张图片

本文出处：
http://www.cnblogs.com/rollenholt/archi … 66179.html

#!/usr/bin/env python
from bs4 import BeautifulSoup       #process html
#from BeautifulSoup import BeautifulStoneSoup #process xml
#import BeautifulSoup                         #all

创建对象：str初始化，常用urllib2或browser返回的html初始化BeautifulSoup对象。
doc = ['hello','This is paragraph one of ptyhonclub.org.','This is paragraph two of pythonclub.org.','']
soup = BeautifulSoup(''.join(doc))
指定编码：当html为其他类型编码（非utf-8和asc ii），比如GB2312的话，则需要指定相应的字符编码，BeautifulSoup才能正确解析。

htmlCharset = "GB2312"
soup = BeautifulSoup(respHtml, fromEncoding=htmlCharset)

2.获取tag内容
   寻找感兴趣的tag块内容，返回对应tag块的剖析树

head = soup.find('head')
#head = soup.head
#head = soup.contents[0].contents[0]

print head

返回内容：hello
说明一下，contents属性是一个列表，里面保存了该剖析树的直接儿子。

html = soup.contents[0]       # <html> ... </html>
head = html.contents[0]       # <head> ... </head>
body = html.contents[1]       # <body> ... </body>

3.获取关系节点
   使用parent获取父节点

body = soup.body
html = body.parent             # html是body的父亲

使用nextSibling, previousSibling获取前后兄弟

head = body.previousSibling    # head和body在同一层，是body的前一个兄弟
p1 = body.contents[0]          # p1, p2都是body的儿子，我们用contents[0]取得p1
p2 = p1.nextSibling            # p2与p1在同一层，是p1的后一个兄弟, 当然body.content[1]也可得到

contents[]的灵活运用也可以寻找关系节点,寻找祖先或者子孙可以采用findParent(s), findNextSibling(s), findPreviousSibling(s)

4.find/findAll用法详解
   函数原型：find(name=None, attrs={}, recursive=True, text=None, **kwargs)，findAll会返回所有符合要求的结果，并以list返回。
  tag搜索

find(tagname)                                  # 直接搜索名为tagname的tag 如：find('head')
find(list)                                     # 搜索在list中的tag，如: find(['head', 'body'])
find(dict)                                     # 搜索在dict中的tag，如:find({'head':True, 'body':True})
find(re.compile(''))                           # 搜索符合正则的tag, 如:find(re.compile('^p')) 搜索以p开头的tag
find(lambda)                       # 搜索函数返回结果为true的tag, 如:find(lambda name: if len(name) == 1) 搜索长度为1的tag
find(True)                                     # 搜索所有tag

  attrs搜索

find(id='xxx')                                  # 寻找id属性为xxx的
find(attrs={id=re.compile('xxx'), algin='xxx'}) # 寻找id属性符合正则且algin属性为xxx的
find(attrs={id=True, algin=None})               # 寻找有id属性但是没有algin属性的

resp1 = soup.findAll('a', attrs = {'href': match1})
resp2 = soup.findAll('h1', attrs = {'class': match2})
resp3 = soup.findAll('img', attrs = {'id': match3})

  text搜索
   文字的搜索会导致其他搜索给的值如：tag, attrs都失效。方法与搜索tag一致

print p1.text
# u'This is paragraphone.'
print p2.text
# u'This is paragraphtwo.'
# 注意：1，每个tag的text包括了它以及它子孙的text。2，所有text已经被自动转为unicode，如果需要，可以自行转码encode(xxx)

  recursive和limit属性
    recursive=False表示只搜索直接儿子，否则搜索整个子树，默认为True。当使用findAll或者类似返回list的方法时，limit属性用于限制返回的数量，如findAll('p', limit=2)： 返回首先找到的两个tag

SND_LOOP
重复地播放声音。SND_ASYNC标识也必须被用来避免堵塞。不能用 SND_MEMORY。

SND_MEMORY
提供给PlaySound()的 sound 参数是一个 WAV 文件的内存映像(memory image)，作为一个字符串。
注意：这个模块不支持从内存映像中异步播放，因此这个标识和 SND_ASYNC 的组合将挂起 RuntimeError。

SND_PURGE
停止播放所有指定声音的实例。

SND_ASYNC
立即返回，允许声音异步播放。

SND_NODEFAULT
不过指定的声音没有找到，不播放系统缺省的声音。

SND_NOSTOP
不中断当前播放的声音。

SND_NOWAIT
如果声音驱动忙立即返回。

MB_ICONASTERISK
播放 SystemDefault 声音。

MB_ICONEXCLAMATION
播放 SystemExclamation 声音。

MB_ICONHAND
播放 SystemHand 声音。

MB_ICONQUESTION
播放 SystemQuestion 声音。

MB_OK
播放 SystemDefault 声音。

python蜂鸣，通过python让电脑发声:
import winsound
winsound.Beep(37, 2000)
37是频率(Hz), 2000是蜂鸣持续多少毫秒(ms).
第一个参数frequency表示分贝数，大小在37到32767之间。第二个参数是持续时间，以毫秒为单位

本文出自 “王伟” 博客，请务必保留此出处http://wangwei007.blog.51cto.com/68019/1231091