1.re.match必须从第一个字符开始匹配，如果第一个字符匹配不上，就返回none
2.re.search是扫描整个字符串，返回第一个字符开始匹配，如果第一个字符匹配不上，就返回None（re.search比re.match好用多了）
3.re.findall搜索字符串，以列表形式返回全部能匹配的子串
4.re.sub替换已有字符串中每一个匹配的子串后，返回替换后的字符串
（例子：import re
5.re.compile将正则字符串编译成正则表达式对象（方便复用）

content = 'Extra stings Hello 1234567 World_This is a Regex Demo Extra stings'

正则表达式匹配到的字符串使用'replace'代替，返回替换后的字符串

content = re.sub('\d+', 'replace', content)
print(content)

输出：Extra stings Hello replace World_This is a Regex Demo Extra stings）

1.使用括号得到匹配目标
2.尽量使用泛匹配（.）
3.尽量使用非贪婪模式（.?）
4.有换行符就用re.S

2020-2-1 15：41

一颗星()和两颗星(*)
Python 函数支持默认参数和可变参数，一颗星表示不限数量的单值参数，两颗星表示不限数量的键值对参数
Python 函数允许同时全部或部分使用固定参数、默认参数、单值（一颗星）可变参数、键值对（两颗星）可变参数，使用时必须按照前述顺序书写。

def do_something(name, age, gender='男', *args, **kwds):
print('姓名：%s，年龄：%d，性别：%s'%(name, age, gender))
print(args)
print(kwds)

do_something('xufive', 50, '男', 175, 75, math=99, english=90)
姓名：xufive，年龄：50，性别：男
(175, 75)
{'math': 99, 'english': 90}

此外，一颗星和两颗星还可用于列表、元组、字典的解包，看起来更像C语言：

a = (1,2,3)
print(a)
(1, 2, 3)
print(a)
1 2 3
b = [1,2,3]
print(b)
[1, 2, 3]
print(b)
1 2 3
c = {'name':'xufive', 'age':51}
print(c)
{'name': 'xufive', 'age': 51}
print(c)
name age
print('name:{name}, age:{age}'.format(*c))
name:xufive, age:51
————————————————
版权声明：本文为CSDN博主「天元浪子」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/xufive/article/details/102856921

yield以及生成器和迭代器

迭代器--》可以像list那样被遍历，但又不占用多少内存（如，在py2时代，range()返回的是list，但如果range（10000000）的话，
会消耗大量内存资源，所以，py2又搞了一个xrange()来解决这个问题。py3则保留了xrange()，但写作range()。xrange()返回的
就是一个迭代器，它可以像list那样被遍历，但又不占多少内存。generator（生成器）是一种特殊的迭代器，只能被遍历一次
，遍历结束，就自动消失了。总之，不管是迭代器还是生成器，都是为了避免使用list，从而节省内存。）

python内置了迭代函数iter，用于生成迭代器，用法如下：
a = [1,2,3]
a_iter = iter(a)
for i in a_iter:
print(i,end=', ')

1,2,3,

yield则是用于构造生成器的。比如，我们要写一个函数，返回从0到正整数的所有整数的平方，传统的代码写法是这样的：

def get_square(n):
result = list()
for i in range(n):
result.append(pow(i,2))
return result

print(get_square(5))
[0,1,4,9,16]

但是如果计算1亿以内的所有整数的平方，这个函数的内存开销会非常大，这时yield就可以大显身手了：

def get_square(n):
for i in range(n):
yield(pow(i,2))

a = get_square(5)
for i in a:
print(i,end=', ')

0,1,4,9,16,
如果再次遍历，则不会有输出了。

装饰器-----》作用就是快速便捷的读出函数运行的时长

如：
import time
def timer(func):
def wrapper(args,kwds):
t0 = time.time()
func(args,**kwds)
t1 = time.time()
print('耗时%0.3f'%（t1-t0,）)
return wrapper

@timer
def do_something(delay):
print('函数do_something开始')
time.sleep(delay)
print('函数do_something结束')

do_something(3)
函数do_something开始
函数do_something结束
耗时3.077

timer()是我们定义的装饰器函数，使用@把它附加在如何一个函数（比如do_something）定义之前，就等于把
新定义的函数，当成了装饰器函数的输入参数。运行do_something()函数，可以理解为执行了timer（do_something）。
细节虽然复杂，不过这么理解不会偏差太大，且更易于把握装饰器的制造和使用。

巧用断言assert
所谓断言，就是声明表达式的布尔值必须为真的判定，否则将触发AssertionError异常。严格来讲，assert是调试手段，
不宜使用在生产环境中，但这不影响我们用断言来实现一些特定功能，比如，输入参数的格式、类型验证等。

def i_want_to_sleep(delay):
assert(isinstance(delay, (int,float))), '函数参数必须为整数或浮点数'
print('开始睡觉')
time.sleep(delay)
print('睡醒了')

i_want_to_sleep(1.1)
开始睡觉
睡醒了
i_want_to_sleep(2)
开始睡觉
睡醒了
i_want_to_sleep('2')
Traceback (most recent call last):
File "<pyshell#247>", line 1, in <module>
i_want_to_sleep('2')
File "<pyshell#244>", line 2, in i_want_to_sleep
assert(isinstance(delay, (int,float))), '函数参数必须为整数或浮点数'
AssertionError: 函数参数必须为整数或浮点数