1.为啥类函数中函数调用需要加self.函数名，因为全局变量的影响
1. a = 1
2. def say():
3. print '调用了全局方法'
4. class people:
5. a = 100
6. def say(self):
7. print '调用了类的方法'
8. def do(self):
9. say()
10. self.say()
11. print 'a = ' , a
12. print 'self.a = ' , self.a
13. p = people()
14. p.do()
15. 结果：
16. 调用了全局方法
17. 调用了类的方法
18. a = 1
19. self.a = 100
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
2.python转义字符
有时我们并不想让转义字符生效，我们只想显示字符串原来的意思，这就要用r和R来定义原始字符串。如：
print r'\t\r'
实际输出为“\t\r”。
转义字符：
\ === 在行尾时代表续行
\\=== 反斜杠符号
\t=== 横向制表符
\v=== 纵向制表符
\'=== 单引号
\"=== 双引号
\000===空
\n=== 换行
\r===回车
\f===换页
\e===转义
\b===退格（backspace）
\oyy===八进制数yy代表的字符如\o12代表换行
\xyy===十进制数yy代表的字符如\xoa代表换行
\a===响铃
\other===其他字符以普通格式输出
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
3.正则表达式[],'字符串'匹配用法
import re
"""
1.匹配字符串包含规则的字段
'findall(rule , target [,flag] )'是个比较直观的函数，就是在目标字符串中查找符合规则的字符串。
第一个参数是规则，第二个参数是目标字符串,返回结果是个列表
r'字符串'可以省去好多需要转义的，如r'\e','\\e'两个是一个意思
"""
s = "abc3isjffabc99skjflAkabc abck^skdflks"
b = re.findall(r'abc', s)
print b
'''
2.[]括起来表示一个字符的集合
[^abc]表示非a，b，c，匹配除abc外任意一个字符
[a-z^A-Z]表示匹配包含a-z，^，A-Z任意一个字符，^放在中间不再表示非的含义
'''
c = re.findall('[abc123]', s)
d = re.findall('[^A-Z^]', s)
e = re.findall('[A-Z^]', s)
print c
print d
print e
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['abc', 'abc', 'abc', 'abc']
['a', 'b', 'c', '3', 'a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
['a', 'b', 'c', '3', 'i', 's', 'j', 'f', 'f', 'a', 'b', 'c', '9', '9', 's', 'k', 'j', 'f', 'l', 'k', 'a', 'b', 'c', ' ', 'a', 'b', 'c', 'k', 's', 'k', 'd', 'f', 'l', 'k', 's']
['A', '^']
Process finished with exit code 0
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
4.正则表达式|的用法
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
1.符号|的用法，[a-z]|[A-Z]与[a-zA-Z]等效，可以理解成或的关系
[|]:|在[]里面不再表示或的关系，而是表示|本身
[]\|[]:在[]外面表示|字符，则必须用\|转义
|：它的有效范围是它两边的整条规则，如a cat|dog 匹配的不是t，d，而是a cat和dog
如果想限定它的有效范围，必需使用一个无捕获组 ‘(?: )’ 包起来。
比如要匹配 ‘ I have a dog’ 或 ’I have a cat’ ，需要写成 r’I have a (?:dog|cat)’ ，
而不能写成 r’I have a dog|cat’
'''
s = "I have a dog, I have a cat||a"
a = re.findall(r"[a-z]|[A-Z]", s)
b = re.findall(r"[|]", s)
c = re.findall(r"[a-z]\|\|[a-z]", s)
print b
print a
print c
d = re.findall(r'I have a (?:dog|cat)', s)
e = re.findall(r'I have a dog|cat', s)
print d
print e
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['|', '|']
['I', 'h', 'a', 'v', 'e', 'a', 'd', 'o', 'g', 'I', 'h', 'a', 'v', 'e', 'a', 'c', 'a', 't', 'a']
['t||a']
['I have a dog', 'I have a cat']
['I have a dog', 'cat']
Process finished with exit code 0
---------------------------------------------------------
5. .?, .+? , .*? , .* , .+ 的用法，前面没有边界时.+,.+?用的多
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
.*?表示匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复，重复次数可以是零次-多次，
从开始到结尾依次匹配。注意每换行制表符的时候会重新匹配
.+?表示这里匹配任意数量重复，匹配成功情况下可能少重复，但是重复次数为一次-多次，从开始到结尾依次匹配
.*表示贪婪匹配尽可能长的匹配，重复次数0-多次，从每行的全部往里面缩减匹配，每换行的时候都会重新匹配
.+表示贪婪匹配尽可能长的匹配，重复次数1-多次，从每行的全部往里面缩减匹配，每换行的时候都会重新匹配
'''
ss = "abbabaababa\nbabba babbbbbbbbbbbbbbbbbbbbbbbbbb"
a = re.findall(r"a.*?b", ss)
b = re.findall(r"a.?b", ss)
c = re.findall(r"a.*b", ss)
d = re.findall(r"a.+b", ss)
e = re.findall(r"a.+?b", ss)
print a
print b
print c
print d
print e
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['ab', 'ab', 'aab', 'ab', 'ab', 'a b', 'ab']
['abb', 'ab', 'aab', 'ab', 'abb', 'a b', 'abb']
['abbabaabab', 'abba babbbbbbbbbbbbbbbbbbbbbbbbbb']
['abbabaabab', 'abba babbbbbbbbbbbbbbbbbbbbbbbbbb']
['abb', 'abaab', 'abb', 'a b', 'abb']
Process finished with exit code 0
----------------------------------------------------------
6.正则表达式贪婪模式，勉强模式，占用模式
'''
假定要分析的字符串是xfooxxxxxxfoo
1.??? 模式.*foo （贪婪模式）: 模式分为子模式p1(.*)和子模式p2(foo)两个部分. 其中p1中的量词匹配方式使用默认方式(贪婪型)。 匹配开始时,吃入所有字符xfooxxxxxxfoo去匹配子模式p1。匹配成功,但这样以来就没有了字符串去匹配子模式p2。本轮匹配失败；第二轮：减少p1部分的匹配量，吐出最后一个字符, 把字符串分割成xfooxxxxxxfo和o两个子字符串s1和s2。 s1匹配p1, 但s2不匹配p2。本轮匹配失败；第三轮，再次减少p1部分匹配量，吐出两个字符, 字符串被分割成xfooxxxxxxf和oo两部分。结果同上。第四轮，再次减少p1匹配量, 字符串分割成xfooxxxxxx和foo两个部分, 这次s1/s2分别和p1/p2匹配。停止尝试,返回匹配成功。
2.??? 模式.*?foo （勉强模式）: 最小匹配方式。第一次尝试匹配, p1由于是0或任意次，因此被忽略，用字符串去匹配p2,失败；第二次，读入第一个字符x, 尝试和p1匹配, 匹配成功; 字符串剩余部分fooxxxxxxfoo中前三个字符和p2也是匹配的. 因此, 停止尝试, 返回匹配成功。在这种模式下，如果对剩余字符串继续去寻找和模式相匹配的子字符串，还会找到字符串末尾的另一个xfoo，而在贪婪模式下，由于第一次匹配成功的子串就已经是所有字符，因此不存在第二个匹配子串。
结果：['xfoo', 'xxxxxxfoo']
3.??? 模式.*+foo （侵占模式）:
python 2.7没有这种模式
也叫占用模式。匹配开始时读入所有字符串, 和p1匹配成功, 但没有剩余字符串去和p2匹配。因此, 匹配失败。返回。
?
简单地说, 贪婪模式和占有模式相比, 贪婪模式会在只有部分匹配成功的条件下, 依次从多到少减少匹配成功部分模式的匹配数量, 将字符留给模式其他部分去匹配; 而占用模式则是占有所有能匹配成功部分,
绝不留给其他部分使用。
'''
----------------------------------------
7.正则表达式一些重要的匹配项目
1）‘^’ 和 ’$’ 匹配字符串开头和结尾
注意 ’^’ 不能在‘ [ ] ’中，否则含意就发生变化，具体请看上面的 ’[‘ ‘]’ 说明。 在多行模式下，它们可以匹配每一行的行首和行尾。具体请看后面 compile 函数说明的 ’M’ 选项部分
2）#‘\d’ 匹配数字
这是一个以 ’/’ 开头的转义字符， ’\d’ 表示匹配一个数字，即等价于 [0-9]
#‘\D’ 匹配非数字
这个是上面的反集，即匹配一个非数字的字符，等价于 [^0-9] 。注意它们的大小写。下面我们还将看到 Python 的正则规则中很多转义字符的大小写形式，代表互补的关系。这样很好记。
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
\d+:表示匹配数字至少一个或多个
\d：等价于[0-9]中单个字符
^:放在[]外面表示匹配行首，空格为断点假如没有re.M则表示整个段落行首，假如有re.M则表示每行行首都会匹配,每行空格后面
不匹配
$:放在[]外面表示匹配行尾，空格作为断点，假如没有re.M则表示整个段落段尾，假如有re.M则表示每行的行尾都会匹配，每行
空格前面不匹配
\D:表示匹配非数字[^0-9]
\D+:表示匹配非数字至少一个或多个
'''
ss = "1 123\n456\n78M9 10"
a = re.findall(r"^\d+", ss)
b = re.findall(r"^\d+",ss, re.M)
c = re.findall(r"\d+$", ss, re.M)
d = re.findall(r"\d+$", ss)
e = re.findall(r"\D+", ss)
print a
print b
print c
print d
print e
f = re.findall(r"\d", ss)
g = re.findall(r"\D", ss)
print f,g
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['1']
['1', '456', '78']
['123', '456', '10']
['10']
[' ', '\n', '\n', 'M', ' ']
['1', '1', '2', '3', '4', '5', '6', '7', '8', '9', '1', '0'] [' ', '\n', '\n', 'M', ' ']
Process finished with exit code 0
3）#‘\w’ 匹配字母和数字单个字符一个个匹配
匹配所有的英文字母和数字，即等价于 [a-zA-Z0-9] 。
#‘\W’ 匹配非英文字母和数字单个字符一个中括号取一个
即 ’\w’ 的补集，等价于 [^a-zA-Z0-9] 。
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
\w:等价[a-z0-9A-Z]匹配数字字母任意一个
\w+:表明以空格和换行为断点，匹配任意一个或一串数字或字母组合
\W:等价[^a-z0-9A-Z]匹配非数字字母任意一个
\W+：以空格和换行为断点，匹配任意非数字和非字母一个或一串
'''
ss = "1 123\n456\n78M9 10"
a = re.findall(r"\W", ss)
b = re.findall(r"\W+", ss)
c = re.findall(r"\w", ss)
d = re.findall(r"\w+", ss)
print a,b
print c,d
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
[' ', '\n', '\n', ' ', ' '] [' ', '\n', '\n', ' ']
['1', '1', '2', '3', '4', '5', '6', '7', '8', 'M', '9', '1', '0'] ['1', '123', '456', '78M9', '10']
Process finished with exit code 0
4）‘\s’ 匹配间隔符
即匹配空格符、制表符、回车符等表示分隔意义的字符，它等价于 [ \t\r\n\f\v] 。（注意最前面有个空格 )
‘\S’ 匹配非间隔符
即间隔符的补集，等价于 [^ \t\r\n\f\v]
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
\s:等价[ \t\n\v\r\f]匹配包含并展示分隔符任意一个
\s+:匹配任意一个或多个连续的分隔符
\S:匹配分隔符但是不展示分隔符，至少后面字符为两个
\S+：匹配包含但不展示一个或多个连续分隔符旁边的字段
'''
ss = "1 123\n456\n 7 8M9 10"
a = re.findall(r"\s+\w+", ss)
c = re.findall(r"\s\w+\s",ss)
b = re.findall(r"\S\w", ss)
d = re.findall(r"\S\w+", ss)
print a,b
print c,d
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
[' 123', '\n456', '\n 7', ' 8M9', ' 10'] ['12', '45', '8M', '10']
[' 123\n', ' 7 '] ['123', '456', '8M9', '10']
Process finished with exit code 0
5）‘\A’ 匹配字符串开头
匹配字符串的开头。它和 ’^’ 的区别是， ’\A’ 只匹配整个字符串的开头，即使在 ’M’ 模式下，它也不会匹配其它行的很首。
‘\Z’ 匹配字符串结尾
匹配字符串的结尾。它和 ’$’ 的区别是， ’\Z’ 只匹配整个字符串的结尾，即使在 ’M’ 模式下，它也不会匹配其它各行的行尾。
例：
6)‘\b’ 匹配单词边界
它匹配一个单词的边界，比如空格等，不过它是一个‘ 0 ’长度字符，它匹配完的字符串不会包括那个分界的字符。而如果用 ’\s’ 来匹配的话，则匹配出的字符串中会包含那个分界符。
例：
‘\B’ 匹配非边界
和 ’\b’ 相反，它只匹配非边界的字符。它同样是个 0 长度字符。
7）(?iLmsux) 编译选项指定
Python 的正则式可以指定一些选项，这个选项可以写在 findall 或 compile 的参数中，也可以写在正则式里，成为正则式的一部分。这在某些情况下会便利一些。具体的选项含义请看后面的 compile 函数的说明。
此处编译选项 ’i’ 等价于 IGNORECASE ，L 等价于 LOCAL ，m 等价于 MULTILINE ， s 等价于 DOTALL ， u 等价于 UNICODE ， x 等价于 VERBOSE 。
请注意它们的大小写。在使用时可以只指定一部分，比如只指定忽略大小写，可写为 ‘(?i)’ ，要同时忽略大小写并使用多行模式，可以写为 ‘(?im)’ 。
另外要注意选项的有效范围是整条规则，即写在规则的任何地方，选项都会对全部整条正则式有效。
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
'''
s = "abc a bcbc de dfsda bcc de 123 sdddbcbcdaad bc ddssa"
a = re.findall(r"\bbc+\b", s)
b = re.findall(r"\b(?:bc)+\b", s)
c = re.findall(r"\Bbc\B", s) # sdddbcbcdaad 匹配这里面两个bc
e = re.findall(r"\B(bc)+\B", s)
# 匹配sdddbcbcdaad里面的bcbc，重复两次匹配上了，只是仅写出了bc
d = re.findall(r"\B(?#jkjkdf)(?:bc)(?#dffs)+\B", s)
# 无捕获组（？：）匹配sdddbcbcdaad以bc为整体匹配重复次数两次并写出
# (？#ksfkd)注释
print a, b
print c, d
print e
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['bcc', 'bc'] ['bcbc', 'bc']
['bc', 'bc'] ['bcbc']
['bc']
Process finished with exit code 0
----------------------------------------------------
8正则表达式重复的使用*,?,+
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
重复
*:前面重复0次或者多次
？：前面字符重复0次或者1次
+：前面字符重复1次或者多次
'''
s = "abc a bcbc de b dfsda bccc de 123 sdddbcbcdaad bc ddssa"
e = re.findall(r"bc*", s) # c的次数可以是零次意味着输出b，也可以是多次输出bcccc...
a = re.findall(r"bc+", s) # c的次数至少出现一次，意味着最少bc，最多bcccc....
c = re.findall(r"bc?", s) # c的次数只能是0次或一次，可以输出b，bc
print e
print a
print c
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['bc', 'bc', 'bc', 'b', 'bccc', 'bc', 'bc', 'bc']
['bc', 'bc', 'bc', 'bccc', 'bc', 'bc', 'bc']
['bc', 'bc', 'bc', 'b', 'bc', 'bc', 'bc', 'bc']
Process finished with exit code 0
-----------------------------------------------------------
9.精确匹配{m},{m，n}次的用法
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
精确匹配
{m}:匹配前面一个字符m次
{m,n}:m<n，匹配前面字符最少m次，最多n次
'''
s = "1 22 333 4444 5555cc 666666 7777777eeee 22333"
e = re.findall(r"\b\d{2,4}\b", s)
a = re.findall(r"\d{2,4}", s)
c = re.findall(r"\b\d{2,4}", s)
d = re.findall(r"\d{2,4}\b", s)
f = re.findall(r"\b\d{3}\b", s)
g = re.findall(r"\b\d{3,}\b", s)
h = re.findall(r"\b3{3}\b", s)
print e
print a
print c
print d
print f
print g,h
结果:
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['22', '333', '4444']
['22', '333', '4444', '5555', '6666', '66', '7777', '777', '2233']
['22', '333', '4444', '5555', '6666', '7777', '2233']
['22', '333', '4444', '6666', '2333']
['333']
['333', '4444', '666666', '22333'] ['333']
Process finished with exit code 0
-------------------------------------------
10.正则表达式.？，.+?,.*?匹配方式的不同
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
.?:匹配0次或1次
.+?:匹配1次或多次
.*?：匹配0次或多次
'''
s = r'/* part 1 */ code /* part 2 *//**/'
a = re.findall(r"/\*.*\*/", s) # /\*后面*号需要转义，然后.*是贪婪匹配，全部往里缩减
c = re.findall(r"/\*.*?\*/", s) # .*?懒惰匹配，从里往外扩充，里面最少0个字符
d = re.findall(r"/\*.+?\*/", s) # .+?懒惰匹配里面至少要一个字符
f = re.findall(r"/\*.?\*/", s) # .?懒惰匹配里面只能零次或一个字符
print a
print c
print d
print f
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['/* part 1 */ code /* part 2 *//**/']
['/* part 1 */', '/* part 2 */', '/**/']
['/* part 1 */', '/* part 2 */']
['/**/']
Process finished with exit code 0
---------------------------------------------------
11.前向界定，后向界定，前向非界定，后向非界定
#‘(?<=…)’ 前向界定
括号中 ’…’ 代表你希望匹配的字符串的前面应该出现的字符串。
#‘(?=…)’ 后向界定
括号中的 ’…’ 代表你希望匹配的字符串后面应该出现的字符串。
#‘(?<!...)’ 前向非界定
只有当你希望的字符串前面不是’…’ 的内容时才匹配
#‘(?!...)’ 后向非界定
只有当你希望的字符串后面不跟着 ’…’ 内容时才匹配。
# -*- coding: UTF-8 -*-
# __author__ = '10459'
import re
'''
(?<=。。。):前向界定，里面为常量，不能正则表达式写
(?=):后向界定，里面可以为常量，也可以为正则表达式
(?<!。。。)：前向非界定
(?!...):后向非界定
'''
s = r'/* part 1 */ code /* part 2 *//**/'
a = re.findall(r"(?<=/\*).*(?=\*/)", s)
c = re.findall(r"(?<=/\*).*?(?=\*/)", s)
d = re.findall(r"(?<=/\*).+?(?=\*/)", s)
f = re.findall(r"(?<=/\*).?(?=\*/)", s)
ss = 'aaa111aaa , bbb222 , 333ccc'
bb = re.findall(r"\d+(?=[a-z]+)", ss)
#不能用r"(?<=[a-z]+)\d+(?=[a-z]+)"前向界定与前向非界定只能用可以确定的常量比如不确定的正则就不能有
这种可以有
aa = re.findall(r"(?<![a-z])\d+", ss)
cc = re.findall(r"[a-z]+(\d+)[a-z]+", ss)
dd = re.findall(r"\d+(?!\w+)", ss)
ff = re.findall(r"\d+(?![a-z]+)", ss)
print cc
print ff
print dd
print bb
print aa
print a
print c
print d
print f
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
['111'] ['11', '222', '33']
['222']
['111', '333']
['11', '22', '333']
[' part 1 */ code /* part 2 *//*', '']
[' part 1 ', ' part 2 ', '']
[' part 1 ', ' part 2 ']
['']
Process finished with exit code 0
--------------------------------------------
12.组的理解
#‘(‘’)’ 无命名组 只展示组里面的东西
最基本的组是由一对圆括号括起来的正则式。比如上面匹配包夹在字母中间的数字的例子中使用的 (/d+) ，我们再回顾一下这个例子：
s = 'aaa111aaa , bbb222 , 333ccc'
dd = re.findall(r'[a-z]+(\d+)[a-z]+', s)
print dd
结果：
['111']
有两个括号，则以元组的形式展示
s = 'aaa111aaa,bbb222,333ccc,444ddd444,555eee666,fff777ggg'
dd = re.findall(r'([a-z]+)\d+([a-z]+)', s)
print dd
结果：
[('aaa', 'aaa'), ('fff', 'ggg')]
可以看到 findall 函数只返回了包含在 ’()’ 中的内容，而虽然前面和后面的内容都匹配成功了，#却并不包含在结果中。
除了最基本的形式外，我们还可以给组起个名字，它的形式是
#‘(?P<name>…)’ 命名组
‘(?P’ 代表这是一个 Python 的语法扩展 ’<…>’ 里面是你给这个组起的名字，比如你可以给一个全部由数字组成的组叫做 ’num’ ，它的形式就是 ’(?P<num>\d+)’ 。起了名字之后，我们就可以在后面的正则式中通过名字调用这个组，它的形式是
#‘(?P=name)’ 调用已匹配的命名组
要注意，再次调用的这个组是已被匹配的组，也就是说它里面的内容是和前面命名组里的内容是一样的。
我们可以看更多的例子：请注意下面这个字符串各子串的特点。
#命名组不同名字的会都打印，同名引用只打印一个，同名引用一定对称的#
s = 'aaa111aaa,bbb222,333ccc,444ddd444,555eee666,fff777ggg'
dd = re.findall(r'(?P<g1>[a-z]+)\d+(?P<g2>[a-z]+)', s)
ds = re.findall(r'(?P<g1>[a-z]+)\d+(?P=g1)', s)
da = re.findall(r'[a-z]+(?P<g2>\d+)(?P<g3>[a-z]+)', s)
print dd
print ds
print da
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/Test11.py"
[('aaa', 'aaa'), ('fff', 'ggg')]
['aaa']#假如上面是aaa111aa，则这里打印aa不是aaa
[('111', 'aaa'), ('777', 'ggg')]
Process finished with exit code 0
我们可以通过命名组的名字在后面调用已匹配的命名组，不过名字也不是必需的。
#‘/number’ 通过序号调用已匹配的组（相同的也会打印出来与名字命名调用有点区别）
正则式中的每个组都有一个序号，序号是按组从左到右，从 1 开始的数字，你可以通过下面的形式来调用已匹配的组
比如上面找出被中间夹有数字的前后同样的字母的例子，也可以写成：
备注：对称的打印
s = 'aaa111aaa,bbb222,333ccc,444ddd444,555eee666,fff777ggg'
dd = re.findall(r'\b(\d+)\w+(\1)\b', s)
结果
[('444', '444')]
。
我们再看一个例子
s = '111aaa222aaa111 , 333bbb444bb33'
dd = re.findall(r'(\d+)([a-z]+)(\d+)(\2)(\1)', s)
print dd
# 找出完全对称的 数字－字母－数字－字母－数字 中的数字和字母
[('111', 'aaa', '222', 'aaa', '111')]
#‘(?( id/name )yes-pattern|no-pattern)’
判断指定组是否已匹配，执行相应的规则
这个规则的含义是，如果 id/name 指定的组在前面匹配成功了，则执行 yes-pattern 的正则式，否则执行 no-pattern 的正则式。
举个例子，比如要匹配一些形如 usr@mail 的邮箱地址，不过有的写成 < usr@mail > 即用一对 <> 括起来，有点则没有，要匹配这两种情况，可以这样写
ee='<usr1@mail1> usr2@maill2 <skkl@2 user3@df> <use4@skf'
kk = re.findall(r"(<)?\s*(\w+@\w+)\s*(?(1)>)", ee)
print kk
结果：[('<', 'usr1@mail1'), ('', 'usr2@maill2'), ('', 'skkl@2'), ('', 'user3@df'), ('', 'use4@skf')]
-------------------------------------------------
13.题目如下
1）启动程序后，让用户输入工资，然后打印商品列表
2）允许用户根据商品编号购买商品
3）用户选择商品后，检测余额是否够，够就直接扣款，不够就提醒
4）课随时退出，退出时，打印已购买商品和余额
# -*- coding: UTF-8 -*-
# __author__ = '10459'
shopping_list = []
goods = [
('iphone', 5000),
('ipad', 4000),
('watch', 7000),
('orange', 400),
('car', 40000),
('pen', 800)
]
salary = raw_input('输入工资：')
if salary.isdigit():
salary = int(salary)
b = True
else:
b = False
while b == False:
print "您的输入有误，请重新输入"
salary = raw_input('请重新输入工资：')
if salary.isdigit():
salary = int(salary)
b = True
else:
b = False
a = True
while a:
for index, product in enumerate(goods):
print index, product
user_choice = raw_input('输入要买的商品:')
if user_choice.isdigit():
user_choice = int(user_choice)
if user_choice < len(goods) and user_choice >= 0:
p_item = goods[user_choice]
if salary >= p_item[1]:
shopping_list.append(p_item)
salary -= p_item[1]
print "add %s to shopping list,you current balance is \033[31;1m%s\033[0m" % (p_item, salary)
else:
print ('\033[41;1m的余额只剩%s,请充值再购买\033[0m' % salary)
else:
print ("goods code %s is not exist" % user_choice)
elif user_choice == "q":
print "-------shoppinglist--------"
sum = 0
for p in shopping_list:
print p
sum += p[1]
print "=========消费金额与余额========="
print "you total cost：%s" % sum
print "you current balance is %s" % salary
exit()
else:
print ("请务必准确输入产品代码，代码必须为整数，谢谢")
结果：
1)
输入工资：qq
您的输入有误，请重新输入
请重新输入工资：1
0 ('iphone', 5000)
1 ('ipad', 4000)
2 ('watch', 7000)
3 ('orange', 400)
4 ('car', 40000)
5 ('pen', 800)
输入要买的商品:q
-------shoppinglist--------
=========消费金额与余额=========
you total cost：0
you current balance is 1
2）
输入工资：40000
0 ('iphone', 5000)
1 ('ipad', 4000)
2 ('watch', 7000)
3 ('orange', 400)
4 ('car', 40000)
5 ('pen', 800)
输入要买的商品:4
add ('car', 40000) to shopping list,you current balance is 0
0 ('iphone', 5000)
1 ('ipad', 4000)
2 ('watch', 7000)
3 ('orange', 400)
4 ('car', 40000)
5 ('pen', 800)
输入要买的商品:1
的余额只剩0,请充值再购买
0 ('iphone', 5000)
1 ('ipad', 4000)
2 ('watch', 7000)
3 ('orange', 400)
4 ('car', 40000)
5 ('pen', 800)
输入要买的商品:q
-------shoppinglist--------
('car', 40000)
=========消费金额与余额=========
you total cost：40000
you current balance is 0
--------------------------------------------------------
14.形参和实参
def test(x,y,z): # x,y,z是形式参数
print x
print y
print z
test(1,2,3) # 位置参数调用，1，2，3实际参数调用 输出1 2 3
test(x=1,z=3,y=2) #关键字调用 随便什么顺序，输出1 2 3
test(3,z=3,y=2) # 混合参数调用，关键字参数不能放在位置参数之前
# test(x=3,3,2) 这个是错的 注意
----------------------------
15.二进制，十六进制，十进制，八进制，ASCII的一些转换
# -*- coding: UTF-8 -*-
# __author__ = '10459'
'''
将二进制，八进制，十六进制转换成10进制用int（）
'''
a = int('1100', base=2)
b = int("ff", base=16)
c = int('16', base=8)
print a, b, c
'''
将整型转换成字符，用chr（）,将字符转换成×××，用ord（）ASCII码
'''
ss = chr(89)
sss = ord("Y")
print ss, sss
'''
将十进制转换成16进制用hex()，将十进制转换成8进制用oct()，将十进制转换成2进制用bin()
'''
sixteen = hex(45)
ba = oct(567)
er = bin(455)
print sixteen, ba, er
结果：
D:\Python27\python.exe "D:/python-pycharm-installpackage/python script/our test/shoppingcart.py"
12 255 14
Y 89
0x2d 01067 0b111000111
Process finished with exit code 0
---------------------------------------------------
16.题目：1，2，3，4中组成互不相同且无重复的三位数
list_num = [1,2,3,4]
list = [i*100 + j*10 + k for i in list_num for j in list_num for k in list_num if ( i != j and i != k and j != k)]
d = len(list)
print('1,2,3,4能组成 %d 个互不相同且无重复数字的三位数。' % d)
print('他们各是:%s' % list)
结果：
1,2,3,4能组成 24 个互不相同且无重复数字的三位数。
他们各是:[123, 124, 132, 134, 142, 143, 213, 214, 231, 234, 241, 243, 312, 314, 321, 324, 341, 342, 412, 413, 421, 423, 431, 432]
----------------
17.
print '''line1
line2
line3'''
或者
print r'''line1
line2
line3'''
结果：
line1
line2
line3
----------------------
