介绍:
本文为学习python笔记,时间为2016年12月27日 。
目录:
-
正则表达式
-
概念
-
基本语法
-
匹配格式
-
常用5种操作
-
字符匹配
-
compile格式
-
实际应用
-
-
冒泡算法
-
时间复杂度
概念:
正则表达式,又称规则表达式。匹配规则。
基本语法:
1
2
3
4
5
6
7
8
9
|
import
re
##导入模块
m
=
re.match(
"abc"
,
"abcdefghi"
)
x
=
re.match(
"abc"
,
"bcdefghi"
)
print
(m)
print
(x)
print
(m.group())
<_sre.SRE_Match
object
; span
=
(
0
,
3
), match
=
'abc'
>
##object 匹配上了
None
##无匹配
abc
## .group匹配的内容
|
匹配格式:
^ : 匹配字符串的开头
$ : 匹配字符串的结尾
.: 匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符。
[...]: 用来表示一组字符,单独列出:[amk] 匹配 'a','m''k'
[^...]:不在[]中的字符
re* 匹配0个或多个的表达式
re+ 匹配1个或多个的表达式
re? 匹配0个或1个由前面的正则表达式定义的片段,非贪婪模式
re{n}
re{n,} 精确匹配n个前面的表达式
a|b 匹配 a 或b
(re) G匹配括号内的表达式,也表示一个组
(?imx) 正则表达式包含三种可选表示 i m x 只影响括号中的区域
(?-imx) 正则表达式关闭 imx
(?:re) 类似(...),但是不表示一个组
(?imx:re) 在括号中使用imx 可选标志
(?-imx:re) 在括号中不使用imx 可选标志
(?#...)注释。
(?=re) 前向可定界定符
(?!re) 前向福鼎界定符
(?>re) 匹配的独立模式。
\w 匹配字母数字 [A-Za-z0-9_]
\W 非字母数据 [^A-Za-z0-9]
\s 任意空白字符 [\f\n\r\t\v]
\S 非任意空白字符 [^\f\n\r\t\v]
\d 任意数字 [0-9]
\D 任意非数字 [^0-9]
\A 字符串开始
\Z 字符串结束,只匹配到换行前的结束字符串
\z 字符串结束
\G 最后匹配完成的位置
\b 一个单词边界
\B 非单词边界
\n,\t 一个换行符
\1..\9 第n个分组的子表达式
\10 匹配第n个分组的子表达式,如果它经匹配。否则指的是八进制字符码的表达式。
常用5种操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
re.match(pattern,string)
##从头匹配
re.search(pattern,string)
##匹配整个字符串,直到找到一个匹配
re.split()
##将匹配到的格式当成分割点对字符串分割成列表
re.findall()
##找到所有要匹配的字符并返回列表格式
re.sub(pattern,repl,string,count,flag)
##替换匹配到的字符
例子:
>>> m
=
re.split(
"[0-9]"
,
"alex1rain2jack3helen rachel8"
)
>>>
print
(m)
[
'alex'
,
'rain'
,
'jack'
,
'helen rachel'
, '']
>>> m
=
re.findall(
"[0-9]"
,
"alex1rain2jack3helen rachel8"
)
>>>
print
(m)
[
'1'
,
'2'
,
'3'
,
'8'
]
>>> m
=
re.sub(
"[0-9]"
,
"|"
,
"alex1rain2jack3helen rachel8"
,count
=
2
)
>>>
print
(m)
alex|rain|jack3helen rachel8
|
备注:
re.match 与re.search的区别
re.match只匹配字符串的开始,如果字符串开始不符合正则表达式,则匹配失败。
re.search匹配整个字符串, 直到找到一个匹配。
字符匹配
python 匹配 python
[Pp]thon Python python
rub[ye] ruby rube
[aeiou] 括号内的任意一个字母
[0-9] 任何数字
[a-z] 任何小写字母
[A-Z] 任何大写字母
[a-zA-Z0-9] 任何字母和数字
[^aeiou] 除了aeiou以外的所有字符
[^0-9] 除了数字外的字符
compile格式
p = re.compile("^[0-9]")
m = p.match('14534Abc')
区别在于,第一种方式是提前对要匹配的格式进行了编译(对匹配公式进行解析),这样再去匹配的时候就不用在编译匹配的格式,第2种简写是每次匹配的时候 都 要进行一次匹配公式的编译,所以,如果你需要从一个5w行的文件中匹配出所有以数字开头的行,建议先把正则公式进行编译再匹配,这样速度会快点。
实际应用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
匹配手机号
m
=
re.search(
"(1)([358]\d{9})"
, phone_str2)
匹配IPV4
m
=
re.search(
"\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}"
, ip_addr)
分组匹配地址
contactInfo
=
'Oldboy School, Beijing Changping Shahe: 010-8343245'
match
=
re.search(r
'(\w+), (\w+): (\S+)'
, contactInfo)
#分组
>>> match.group(
1
)
'Doe'
>>> match.group(
2
)
'John'
>>> match.group(
3
)
'555-1212'
match
=
re.search(r
'(?P<last>\w+), (?P<first>\w+): (?P<phone>\S+)'
, contactInfo)
>>> match.group(
'last'
)
'Doe'
>>> match.group(
'first'
)
'John'
>>> match.group(
'phone'
)
'555-1212'
匹配email
m
=
re.search(r
"[0-9.a-z]{1,26}@[0-9.a-z]{1,20}.[0-9a-z]{0,8}.[0-9a-z]{0,8}"
, email)
##r不转意
|
冒泡算法
将不规则的数组按照从小到大的顺序进行排序
1
2
3
4
5
6
7
8
|
data
=
[
10
,
4
,
33
,
21
,
54
,
3
,
8
,
11
,
5
,
22
,
2
,
1
,
17
,
13
,
6
]
for
j
in
range
(
1
,
len
(data)):
for
i
in
range
(
len
(data)
-
j):
##-j 是因为第一次排序54,已经到最后了,不用排序了。第二次33到最后了,不用比较了。依次只比较前面的数组。
if
data[i] > data[i
+
1
]:
## 10,4进行比较
tmp
=
data[i
+
1
]
##tmp=4
data[i
+
1
]
=
data[i]
##4变10
data[i]
=
tmp
##10变成4
print
(data)
|
结果
[4, 10, 21, 33, 3, 8, 11, 5, 22, 2, 1, 17, 13, 6, 54]
[4, 10, 21, 3, 8, 11, 5, 22, 2, 1, 17, 13, 6, 33, 54]
[4, 10, 3, 8, 11, 5, 21, 2, 1, 17, 13, 6, 22, 33, 54]
[4, 3, 8, 10, 5, 11, 2, 1, 17, 13, 6, 21, 22, 33, 54]
[3, 4, 8, 5, 10, 2, 1, 11, 13, 6, 17, 21, 22, 33, 54]
[3, 4, 5, 8, 2, 1, 10, 11, 6, 13, 17, 21, 22, 33, 54]
[3, 4, 5, 2, 1, 8, 10, 6, 11, 13, 17, 21, 22, 33, 54]
[3, 4, 2, 1, 5, 8, 6, 10, 11, 13, 17, 21, 22, 33, 54]
[3, 2, 1, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
[2, 1, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
[1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
[1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
[1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
[1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
[1, 2, 3, 4, 5, 6, 8, 10, 11, 13, 17, 21, 22, 33, 54]
时间复杂度
(1)时间频度 一个算法执行所耗费的时间,从理论上是不能算出来的,必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试,只需知道哪个算法花费的时间多,哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
(2)时间复杂度 在刚才提到的时间频度中,n称为问题的规模,当n不断变化时,时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此,我们引入时间复杂度概念。 一般情况下,算法中基本操作重复执行的次数是问题规模n的某个函数,用T(n)表示,若有某个辅助函数f(n),使得当n趋近于无穷大时,T(n)/f(n)的极限值为不等于零的常数,则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n)),称O(f(n)) 为算法的渐进时间复杂度,简称时间复杂度。
指数时间
指的是一个问题求解所需要的计算时间m(n),依输入数据的大小而呈指数成长(即输入数据的数量依线性成长,所花的时间将会以指数成长)
1 2 3 4 5 |
|
第一个for循环的时间复杂度为Ο(n),第二个for循环的时间复杂度为Ο(n2),则整个算法的时间复杂度为Ο(n+n2)=Ο(n2)。
常数时间
若对于一个算法,的上界与输入大小无关,则称其具有常数时间,记作时间。一个例子是访问数组中的单个元素,因为访问它只需要一条指令。但是,找到无序数组中的最小元素则不是,因为这需要遍历所有元素来找出最小值。这是一项线性时间的操作,或称时间。但如果预先知道元素的数量并假设数量保持不变,则该操作也可被称为具有常数时间。
对数时间
若算法的T(n) = O(log n),则称其具有对数时间
对数时间的算法是非常有效的,因为每增加一个输入,其所需要的额外计算时间会变小。
递归地将字符串砍半并且输出是这个类别函数的一个简单例子。它需要O(log n)的时间因为每次输出之前我们都将字符串砍半。 这意味着,如果我们想增加输出的次数,我们需要将字符串长度加倍。
线性时间
如果一个算法的时间复杂度为O(n),则称这个算法具有线性时间,或O(n)时间。非正式地说,这意味着对于足够大的输入,运行时间增加的大小与输入成线性关系。例如,一个计算列表所有元素的和的程序,需要的时间与列表的长度成正比。