您的位置：首页 > 编程语言 > Python开发

python爬虫入门（1）基础知识；正则表达式 Re 模块

2017-08-05 23:04 1281 查看

我们会学到python内置方法，Re模块，Urllib模块，Urllib2模块，cookielib模块，我们先把基础函数都掌握了，基础打牢，再去实战，再研究高级的知识。

一、python 基础知识复习

我将列出与c++不同的一些基础知识

List （c++中的数组，也可以说是vector因为他可以自由伸缩长度，Java和C#中也有list）

构造

list = ["1", "2"]

切片 （C++中的下标索引）

poets = ["libai", "dufu", "luyou", "wangwei", "sushi", "qinguan", "qinshaoyou", "liyu", "yanshu"]
poets[1:5]  # 从下标1开始取，至第5个内（不包括5）1 <= x < 5
# ['dufu', 'luyou', 'wangwei', 'sushi']
poets[-1]  # -1直接获取最后一个元素
# yanshu
poets[3:-1]  # 如果想取最后一个元素，不能这样写，这样包含-1在内，应该是这样写 poets[3:]
# ['wangwei', 'sushi', 'qinguan', 'qinshaoyou', 'liyu']
poets[::2]  # 最后一个参数 相当于步长，每隔元素就取一个
# ['libai', 'luyou', 'sushi', 'qinshaoyou', 'yanshu']

追加

poets.append("dumu")

#当然是插在最后面的，学过java的或者c++ STL的应该很熟悉

插入

poets.insert(1, sancao)

删除

poets.remove("libai")

统计

List1 = ["a", "v", "b", "a", "a", " ", "",1]
List1.count("")  # 统计元素的个数
# 3

获取下标

List1 = ["a", "v", "b", "a", "a", " ", "", 1]
List1.index("a")  # 如果有多个相同，至返回第一个元素的下标

排序，翻转

List3.sort()

List3.reverse()

拷贝

List2 = List1.copy()

tuple（元组，元组和list是差不多的，如果你学java会发现list和tuple的区别很想string和stringbuffer）

构造

tup =  ("1", "2") 元组小括号，列表中括号

切片 （C++中的下标索引） 和list相同

修改不可修改

删除元组 del tup

元组内置函数

序号	方法及描述
1	cmp(tuple1, tuple2) 比较两个元组元素。
2	len(tuple) 计算元组元素个数。
3	max(tuple) 返回元组中元素最大值。
4	min(tuple) 返回元组中元素最小值。
5	tuple(seq) 将列表转换为元组。

Dict（c++中的map , php中的array，java中也有）

构造

dic = {

'a':'1234',

访问

dic['a']

修改

dic['a']='2345'

删除

 deldic['a']

del.clear()

序号	函数及描述
1	dict.clear() 删除字典内所有元素
2	dict.copy() 返回一个字典的浅复制
3	dict.fromkeys(seq[, val])) 创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
4	dict.get(key, default=None) 返回指定键的值，如果值不在字典中返回default值
5	dict.has_key(key) 如果键在字典dict里返回true，否则返回false
6	dict.items() 以列表返回可遍历的(键, 值) 元组数组
7	dict.keys() 以列表返回一个字典所有的键
8	dict.setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9	dict.update(dict2) 把字典dict2的键/值对更新到dict里
10	dict.values() 以列表返回字典中的所有值
11	pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
12	popitem() 随机返回并删除字典中的一对键和值。

生成列表

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

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

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

条件过滤

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

请编写一个函数，它接受一个 list，然后把list中的所有字符串变成大写后返回，非字符串元素将被忽略。

提示：

1. isinstance(x, str) 可以判断变量 x 是否是字符串；

2. 字符串的 upper() 方法可以返回大写的字母。

def toUppers(L):
    return [ i.upper() for i in L if isinstance(i,str) ]
print toUppers(['Hello', 'world', 101])

内置函数，慢慢学吧！

abs()	divmod()	input()	open()	staticmethod()
all()	enumerate()	int()	ord()	str()
any()	eval()	isinstance()	pow()	sum()
basestring()	execfile()	issubclass()	print()	super()
bin()	file()	iter()	property()	tuple()
bool()	filter()	len()	range()	type()
bytearray()	float()	list()	raw_input()	unichr()
callable()	format()	locals()	reduce()	unicode()
chr()	frozenset()	long()	reload()	vars()
classmethod()	getattr()	map()	repr()	xrange()
cmp()	globals()	max()	reversed()	zip()
compile()	hasattr()	memoryview()	round()	__import__()
complex()	hash()	min()	set()
delattr()	help()	next()	setattr()
dict()	hex()	object()	slice()
dir()	id()	oct()	sorted()	exec 内置表达式

二、正则表达式

正则表达式在哪都很重要，一个程序员没有一个不会正则表达式的。。正则表达式其实就是用来匹配字符串的，比如你要的数据是王某某，那么他可以匹配到姓王的人，很方便

正则表达式速查表

字符	描述
\	将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“ n ”匹配字符“ n ”。“ \n ”匹配一个换行符。串行“ \\ ”匹配“ \ ”而“ \( ”则匹配“ ( ”。
^	匹配输入字符串的开始位置。如果设置了RegExp对象的Multiline属性，^也匹配“ \n ”或“ \r ”之后的位置。
$	匹配输入字符串的结束位置。如果设置了RegExp对象的Multiline属性，$也匹配“ \n ”或“ \r ”之前的位置。
*	匹配前面的子表达式零次或多次。例如，zo能匹配“ z ”以及“ zoo ”。等价于{0,}。
+	匹配前面的子表达式一次或多次。例如，“ zo+ ”能匹配“ zo ”以及“ zoo ”，但不能匹配“ z ”。+等价于{1,}。
?	匹配前面的子表达式零次或一次。例如，“ do(es)? ”可以匹配“ does ”或“ does ”中的“ do ”。?等价于{0,1}。
{n}	n是一个非负整数。匹配确定的n次。例如，“ o{2} ”不能匹配“ Bob ”中的“ o ”，但是能匹配“ food ”中的两个o。
{n,}	n是一个非负整数。至少匹配n次。例如，“ o{2,} ”不能匹配“ Bob ”中的“ o ”，但能匹配“ foooood ”中的所有o。“ o{1,} ”等价于“ o+ ”。“ o{0,} ”则等价于“ o* ”。
{n,m}	m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“ o{1,3} ”将匹配“ fooooood ”中的前三个o。“ o{0,1} ”等价于“ o? ”。请注意在逗号和两个数之间不能有空格。
?	当该字符紧跟在任何一个其他限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串“ oooo ”，“ o+? ”将匹配单个“ o ”，而“ o+ ”将匹配所有“ o ”。
.	匹配除“ \ n ”之外的任何单个字符。要匹配包括“ \ n ”在内的任何字符，请使用像“ (.\|\n) ”的模式。
(pattern)	匹配pattern并获取这一匹配。所获取的匹配可以从产生的Matches集合得到，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“ $ ”或“ $ ”。
(?:pattern)	匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用或字符“ (\|) ”来组合一个模式的各个部分是很有用。例如“ industr(?:y\|ies) ”就是一个比“ industry\|industries ”更简略的表达式。
(?=pattern)	正向肯定预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“ Windows(?=95\|98\|NT\|2000) ”能匹配“ Windows2000 ”中的“ Windows ”，但不能匹配“ Windows3.1 ”中的“ Windows ”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始。
(?!pattern)	正向否定预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如“ Windows(?!95\|98\|NT\|2000) ”能匹配“ Windows3.1 ”中的“ Windows ”，但不能匹配“ Windows2000 ”中的“ Windows ”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始
(?<=pattern)	反向肯定预查，与正向肯定预查类拟，只是方向相反。例如，“ (?<=95\|98\|NT\|2000)Windows ”能匹配“ 2000Windows ”中的“ Windows ”，但不能匹配“ 3.1Windows ”中的“ Windows ”。
(?<!pattern)	反向否定预查，与正向否定预查类拟，只是方向相反。例如“ (?<!95\|98\|NT\|2000)Windows ”能匹配“ 3.1Windows ”中的“ Windows ”，但不能匹配“ 2000Windows ”中的“ Windows ”。
x\|y	匹配x或y。例如，“ z\|food ”能匹配“ z ”或“ food ”。“ (z\|f)ood ”则匹配“ zood ”或“ food ”。
[xyz]	字符集合。匹配所包含的任意一个字符。例如，“ [abc] ”可以匹配“ plain ”中的“ a ”。
[^xyz]	负值字符集合。匹配未包含的任意字符。例如，“ [^abc] ”可以匹配“ plain ”中的“ p ”。
[a-z]	字符范围。匹配指定范围内的任意字符。例如，“ [a-z] ”可以匹配“ a ”到“ z ”范围内的任意小写字母字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。例如，“ [^a-z] ”可以匹配任何不在“ a ”到“ z ”范围内的任意字符。
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如，“ er\b ”可以匹配“ never ”中的“ er ”，但不能匹配“ verb ”中的“ er ”。
\B	匹配非单词边界。“ er\B ”能匹配“ verb ”中的“ er ”，但不能匹配“ never ”中的“ er ”。
\cx	匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。否则，将c视为一个原义的“ c ”字符。
\d	匹配一个数字字符。等价于[0-9]。
\D	匹配一个非数字字符。等价于[^0-9]。
\f	匹配一个换页符。等价于\x0c和\cL。
\n	匹配一个换行符。等价于\x0a和\cJ。
\r	匹配一个回车符。等价于\x0d和\cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。
\S	匹配任何非空白字符。等价于[^ \f\n\r\t\v]。
\t	匹配一个制表符。等价于\x09和\cI。
\v	匹配一个垂直制表符。等价于\x0b和\cK。
\w	匹配包括下划线的任何单词字符。等价于“ [A-Za-z0-9_] ”。
\W	匹配任何非单词字符。等价于“ [^A-Za-z0-9_] ”。
\xn	匹配n，其中n为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，“ \x41 ”匹配“ A ”。“ \x041 ”则等价于“ \x04&1 ”。正则表达式中可以使用ASCII编码。.
\num	匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“ (.)\1 ”匹配两个连续的相同字符。
\n	标识一个八进制转义值或一个向后引用。如果\n之前至少n个获取的子表达式，则n为向后引用。否则，如果n为八进制数字（0-7），则n为一个八进制转义值。
\nm	标识一个八进制转义值或一个向后引用。如果\nm之前至少有nm个获得子表达式，则nm为向后引用。如果\nm之前至少有n个获取，则n为一个后跟文字m的向后引用。如果前面的条件都不满足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。
\nml	如果n为八进制数字（0-3），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。
\un	匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（©）。

常用正则表达式

用户名	/^[a-z0-9_-]{3,16}$/
密码	/^[a-z0-9_-]{6,18}$/
十六进制值	/^#?([a-f0-9]{6}\|[a-f0-9]{3})$/
电子邮箱	/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/ /^[a-z\d]+(\.[a-z\d]+)*@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/
URL	/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-])\/?$/
IP 地址	/((2[0-4]\d\|25[0-5]\|[01]?\d\d?)\.){3}(2[0-4]\d\|25[0-5]\|[01]?\d\d?)/ /^(?:(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)$/
HTML 标签	/^<([a-z]+)([^<]+)(?:>(.)<\/\1>\|\s+\/>)$/
删除代码\\注释	(?<!http:\|\S)//.*$
Unicode编码中的汉字范围	/^[\u2E80-\u9FFF]+$/

python re 模块下面我会翻译re模块在官方的解释，使用和实例，最重要的是match和search
参考了菜鸟教程

re.compile函数

这个匹配的字符串要用到match函数和search函数中，其方法效果是等价的，看下面的例子

The sequence

prog = re.compile(pattern)
result = prog.match(string)

is equivalent to

result = re.match(pattern, string)

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。re.match(正则表达式, string,表达式修饰符（选填）)

print(re.match('www','www.runoob.com').span())# 在起始位置匹配print(re.match('com','www.runoob.com'))# 不在起始位置匹配>> (0,3)>> None

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。re.search(正则表达式，string,表达式修饰符（选填））

print(re.search('www','www.runoob.com').span())# 在起始位置匹配print(re.search('com','www.runoob.com').span())# 不在起始位置匹配
>> (0,3)>> (11,14)

正则表达式修饰符 - 可选标志

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

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

group

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

re.sub方法

用于替换字符串中的的匹配项。re.sub(正则表达式，替换字符串或函数，string，匹配后的最大次数（默认全部），表达式修饰符）

import re phone = "2004-959-559 # 这是一个国外电话号码" # 删除字符串中的 Python注释 num = re.sub(r'#.*$', "", phone)print "电话号码是: ", num #2004-959-559# 删除非数字(-)的字符串 num = re.sub(r'\D', "", phone)print "电话号码是 : ", num#2004959559

如果替换的是函数：

>>> def dashrepl(matchobj):
...     if matchobj.group(0) == '-': return ' '
...     else: return '-'
>>> re.sub('-{1,2}', dashrepl, 'pro- - - -gram-files')
'pro- -gram files'
>>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
'Baked Beans & Spam' #上面这个函数的意思就是，先找到匹配的字符串{ - {1，2}}即 - - 或者 - ，这里是group(0)，所以如果是 - 就变成空，如果是 - - 就变成 -

re.split方法

用于分割字符串中的的匹配项。re.split(正则表达式，string，maxsplit，表达式修饰符）

>>> re.split('\W+', 'Words, words, words.')
['Words', 'words', 'words', '']
>>> re.split('(\W+)', 'Words, words, words.')
['Words', ', ', 'words', ', ', 'words', '.', '']
>>> re.split('\W+', 'Words, words, words.', 1)
['Words', 'words, words.']
>>> re.split('[a-f]+', '0a3B9', flags=re.IGNORECASE)
['0', '3', '9']

re.escape方法

返回的数都有反斜杠。re.escape(正则表达式）

>>> print re.escape('python.exe')
python\.exe

>>> legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
>>> print '[%s]+' % re.escape(legal_chars)
[abcdefghijklmnopqrstuvwxyz0123456789\!\#\$\%\&\'\*\+\-\.\^\_\`\|\~\:]+

>>> operators = ['+', '-', '*', '/', '**']
>>> print '|'.join(map(re.escape, sorted(operators, reverse=True)))
\/|\-|\+|\*\*|\*

re.findall方法

返回所有匹配的字符串。findall(正则表达式，string，表达修饰符）

>>> import re
>>> s = "adfad asdfasdf asdfas asdfawef asd adsfas "

>>> reObj1 = re.compile('((\w+)\s+\w+)')
>>> reObj1.findall(s)
[('adfad asdfasdf', 'adfad'), ('asdfas asdfawef', 'asdfas'), ('asd adsfas', 'asd')]

>>> reObj2 = re.compile('(\w+)\s+\w+')
>>> reObj2.findall(s)
['adfad', 'asdfas', 'asd']

>>> reObj3 = re.compile('\w+\s+\
c546
w+')
>>> reObj3.findall(s)
['adfad asdfasdf', 'asdfas asdfawef', 'asd adsfas']
@1.当给出的正则表达式中带有多个括号时，列表的元素为多个字符串组成的tuple，tuple中字符串个数与括号对数相同，字符串内容与每个括号内的正则表达式相对应，并且排放顺序是按括号出现的顺序。@2.当给出的正则表达式中带有一个括号时，列表的元素为字符串，此字符串的内容与括号中的正则表达式相对应（不是整个正则表达式的匹配内容）。@3.当给出的正则表达式中不带括号时，列表的元素为字符串，此字符串为整个正则表达式匹配的内容。这个findall函数的原博主：点击打开链接

基本上re模块的函数都在这里了。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航

python爬虫入门（1） 基础知识 ； 正则表达式 Re 模块