介绍

正则表达式是一种用形式化语法描述的文本匹配模式,可以进行复杂的字符串匹配。
Python中的正则表达式通过re模块提供,功能比Python内置的str更强,但是速度没有str提供的方法快。
因此如果内置的str方法可以解决,那么直接用就可以。如果不好解决,再使用正则。

1.查找文本中的模式

'''
re最常见的方法就是搜索文本中的模式。match和search函数接收pattern(模式)和text(文本)作为输入,找到这个模式时,就返回一个Match对象。
如果没有找到模式,则返回None。
每个Match对象包含有关匹配性质的信息,包括原输入字符串,所使用的正则表达式,以及模式在原字符串中出现的位置。
'''
pattern = "this"
text = "你知道this的含义吗?"
match = re.search(pattern, text)
print(match) # <re.Match object; span=(3, 7), match='this'>
print(match.start()) # 3
print(match.end()) # 7
print(text[match.start(): match.end()]) # this # 以上是search,那么match呢?
match = re.match(pattern, text)
print(match) # None
# 返回结果为None,match和search比较类似,但match只能从头匹配查找, 而search可以在字符串的任意位置匹配查找。 # 即使有多个满足条件的也只会返回第一个。
print(re.search("this", "123this456this789this")) # <re.Match object; span=(3, 7), match='this'> # 如果没有则返回None,此时调用下面的start或end方法也会报错。会抛出AttributeError: 'NoneType' object has no attribute 'xxxxxx'
# 因此可以加上一层判断
match = re.match(pattern, text)
if match:
print(match.start())

2.编译表达式

import re

'''
我们也可以将模式进行一个编译,比如我们有很多手机号,但我只查询以135开头的。
按照我们刚才讲的,可以这么做。
for number in number_list:
if re.match("135", number):
print(number)
这么做毫无疑问是可行的,但是我们每循环一次,pattern都要编译一次。既然pattern是固定不变的,我们是不是可以提前将它编译好呢?
答案是可以的
'''
# 得到编译之后的对象
comp = re.compile("135")
# 下面就可以直接使用这个编译的对象进行查找就可以了
number_list = ["13541258742", "18845214415", "13512441552"]
for number in number_list:
# 可以看到,如果使用re的话,需要传入pattern,但是我们将pattern进行编译之后,就可以直接调用了。
if comp.match(number):
print(number)
'''
13541258742
13512441552
''' '''
re.match(pattern, text) <==> re.compile(pattern).match(text)
'''
# 可以对比字符串,准确的说应该对比成类与对象
s = "abc|abcd|efg"
print(s.split("|")) # ['abc', 'abcd', 'efg']
# 也可以使用str这个类来调用,但是不方便,于是我们都使用字符串本身,也就是类str的实例对象
print(str.split(s, "|")) # ['abc', 'abcd', 'efg'] # summary:可以传入pattern和text作为参数,调用re.match,也可以将pattern编译之后,用编译之后的对象调用match方法,此时只需传入text

3.多重匹配

import re

'''
到目前为止,我们所获取的都是单个实例。如何将满足条件的所有文本全部获取呢?
可以使用findall函数
'''
pattern = "abc"
text = "abc|abc|abc|abc"
print(re.findall(pattern, text)) # ['abc', 'abc', 'abc', 'abc']
# 可以看到,直接将满足条件的所有实例全部以列表的形式获取出来了,并且如果满足条件的实例只有一个,那么得到的仍是一个列表,只是列表里面只有一个元素 # 除此之外还有一个迭代器模式
res = re.finditer(pattern, text)
print(res) # <callable_iterator object at 0x00000000029C4400>
for v in res:
print(v)
'''
<re.Match object; span=(0, 3), match='abc'>
<re.Match object; span=(4, 7), match='abc'>
<re.Match object; span=(8, 11), match='abc'>
<re.Match object; span=(12, 15), match='abc'>
'''
# 得到的是一个Match对象

4.模式语法

import re

'''
除了简单的字面量文本字符串,正则表达式还支持更强大的模式。
'''
# 重复
'''
.:代表除换行符之外的任意字符
*:重复0次或者任意多次
+:重复1次或者任意多次
?:重复0次或者1次
{m}:出现m次
{m,n}:出现m次到n次,包含m和n,并且注意,逗号两边不要有空格
{m,}:省略n,那么表示至少出现m次,最多则没有限制 因此:* == {0,} + == {1,} ? == {0,1}
''' # b出现一次到三次,注意这里不是ab出现一到三次,*+?{}只会作用于它的前一个字符
print(re.search("ab{1,3}", "abcabbc")) # <re.Match object; span=(0, 2), match='ab'>
print(re.search("ab{2,3}", "abcabbc")) # <re.Match object; span=(3, 6), match='abb'>
'''
可以看到都是从头开始找,开头是ab满足"ab{1,3}",即使后面有abb也不会匹配了
而"ab{2,3}"则要求b至少出现两次,因此找到了后面的abb
''' # 可以看到,要求是一到三次,ab,abb,abbb都符合,最终是取了abbb。
# 正则的模式则是贪婪模式,能往多了匹配就往多了匹配
print(re.search("ab{1,3}", "abbbbb")) # <re.Match object; span=(0, 4), match='abbb'> # *+?这些元字符也是同样的道理
print(re.search("ab*", "abbbbb")) # <re.Match object; span=(0, 6), match='abbbbb'>
print(re.search("ab+", "abbbbb")) # <re.Match object; span=(0, 6), match='abbbbb'>
print(re.search("ab?", "abbbbb")) # <re.Match object; span=(0, 2), match='ab'> # 那么如何不使用这种贪婪模式呢?可以直接在*+?{}后面加上?即可,表示关闭贪婪模式
# 出现一到三次,关闭贪婪,只获取一个b
print(re.search("ab{1,3}?", "abbbbb")) # <re.Match object; span=(0, 2), match='ab'>
# *出现0次或多次,关闭贪婪模式,获取0次
print(re.search("ab*?", "abbbbb")) # <re.Match object; span=(0, 1), match='a'>
# 显然获取一次
print(re.search("ab+?", "abbbbb")) # <re.Match object; span=(0, 2), match='ab'>
# 出现0次或一次,关闭贪婪模式后显然获取0次
print(re.search("ab??", "abbbbb")) # <re.Match object; span=(0, 1), match='a'>
# .表示除了换行符的任意字符
print(re.search(".{1,5}", "aaaaa")) # <re.Match object; span=(0, 5), match='aaaaa'>
print(re.search(".{1,5}", "aa\naa")) # <re.Match object; span=(0, 2), match='aa'> # 字符集
'''
下面问题又来了,如果我想获取以a开头以c结尾,中间的一个字符必须是love中的一个,想获取这样的字符该怎么办呢?
首先两端好解决,关键是中间的字符要怎么表示?
这个时候字符集就派上用场呢?
[love]:用中括号把多个字符组合起来即可,表示匹配l、o、v、e四个字符中的一个
'''
print(re.findall("a[love]c", "awc|aec|afc|akc|adc")) # ['aec']
# 字符集[love]就可以看做是一个整体,也可以搭配元字符使用
'''
[love]{1,3} 表示匹配出现一到三次的字符,什么的字符呢?l、o、v、e四个字符当中的某一个字符
'''
# v在[love]当中,匹配vvv
print(re.findall("[love]{1,3}", "vvv")) # ['vvv']
# k不在但是v在,匹配vv
print(re.findall("[love]{1,3}", "kvv")) # ['vv']
# 匹配v
print(re.findall("[love]{1,3}", "kv")) # ['v']
# a不在,但ve在,匹配ve
print(re.findall("[love]{1,3}", "ave")) # ['ve']
# findall是查找所有,l在[love]里面,o在,v在,但是最多出现三次匹配成功结束。继续查找,最后的e也在,但是_不在,所以匹配结束,得到e。
# y不在,但是o在,u又不在,所以又匹配出e。因此最终结果是['lov', 'e', 'o']。
print(re.findall("[love]{1,3}", "love_you")) # ['lov', 'e', 'o'] # 那我如果想取反呢?也就是我要不在love里面的字符。可以使用[^love],表示非l、o、v、e的任意字符 # 这便是字符集,但是又有一个问题。如果我想获取为小写字母的字符呢?难道把26的字母都写一遍吗?当然不用
# [a-z]表示所有的小写字母
# [A-Z]表示所有的大写字母
# [0-9]表示所有的数字
# [a-zA-Z0-9]表示所有的字母和数字
print(re.findall("[a-z][A-Z]", "aB|ac")) # ['aB']
print(re.findall("[a-zA-Z]", "a|C|4|尻")) # ['a', 'C']
print(re.findall("[a-zA-Z0-9]", "a|C|4|尻")) # ['a', 'C', '4'] # 转义码
# \d表示数字
# \D表示非数字
# \w表示字母、数字,注意:这里包括中文
# \W表示非字母数字
# \s表示空白符(制表符、空格、换行等)
# \S表示非空白符 # 但是\在操作系统中会先做一层转义,因此需要两个\。在操作系统层面上,两个\变成一个\,然后再和d组合成\d进行正则比配
print(re.search("\\d{1,3}", "1234")) # <re.Match object; span=(0, 3), match='123'>
# 那如果我想匹配\呢?
print(re.search("\\\\hello", "\\hello")) # <re.Match object; span=(0, 6), match='\\hello'>
'''
要知道\在正则中也是有含义的,因此要匹配纯反斜杠,也需要做一次转义。
所以需要四个\,首先在在操作系统层面会转义,将四个\变成两个\,在正则中两个\变成一个\,此时的\便是普通的字符
但是这样会很麻烦,因此可以在字符串的开头加上一个r,表示这是原生的字符串,你不需要给我做任何的转义
'''
# 此时只需要一个反斜杠即可,可以看到Python中的\w是包含中文的
print(re.search(r"\w{1,2}", "古明地觉")) # <re.Match object; span=(0, 2), match='古明'> # 锚定
'''
有时除了匹配模式的内容外,我们还要对内容的位置进行一个限制。
^:这个符号我们刚才好像见过,[^seq],表示不在seq里面的字符,但是如果放在开头的位置,则表示以某字符开头,如^abc则表示以abc开头的字符
$:表示以某字符结尾。如abc$表示以abc结尾的字符
\b:单词开头或末尾的空串
\B:不在单词开头或末尾的空串
'''
print(re.search(r"^abc", "abcd")) # <re.Match object; span=(0, 3), match='abc'>
print(re.search(r"^abc", "aabcd")) # None print(re.search(r"abc$", "dabc")) # <re.Match object; span=(1, 4), match='abc'>
print(re.search(r"abc$", "abcd")) # None

5.限制搜索

import re

'''
已经编译的正则表达式,还可以指定查找的范围
'''
pattern = re.compile(r"123")
text = "123|123|123"
print(pattern.search(text, pos=2, endpos=7)) # <re.Match object; span=(4, 7), match='123'>
# 指定从2开始,7结束

6.用组解析匹配

import re

'''
有时我们想要提取某些内容中间的内容,比如xxxabcxxx,我想要夹在xxx和xxx之间的内容怎么办呢?
这个时候就可以用到分组
'''
# 有两个abc,但我要的是夹在xxx和xxx之间的abc
match = re.search(r"xxx(abc)xxx", "abcxxxabcxxx")
print(match) # <re.Match object; span=(3, 12), match='xxxabcxxx'>
# 这样匹配依旧会匹配全局,怎么样才能把括号里面的内容给抽取出来呢?
print(match.group(0)) # xxxabcxxx
print(match.group(1)) # abc
'''
可以使用group函数,参数默认是0,表示全局。
参数为1,表示第一个括号里面的内容,参数为n,表示第n个括号里面的内容
''' match = re.search(r"123(.+?)456(.+?)789", "123abc456def789")
print(match.group(0)) # 123abc456def789
print(match.group(1)) # abc
print(match.group(2)) # def # 那么问题来了,如果是这样呢?
match = re.search(r"123((.+?)456(.+?))789", "123abc456def789")
print(match.group(0)) # 123abc456def789
print(match.group(1)) # abc456def
print(match.group(2)) # abc
print(match.group(3)) # def
'''
可以看到,我在(.+?)456(.+?)外层又加上了一层括号
分组的顺序,是从左往右,找到了(,就会进行分组,至于),会自动进行匹配,所以group(1)是最外层的abc456def
group(2)是456左边的(.+?),group(3)是456右边的(.+?)
''' # 此外还可以给组进行命名。只需要在括号里面加上?P<name>即可,name是我们指定的分组的名字
match = re.search(r"123(?P<yoyoyo>.+?)456(?P<哈哈哈>.+?)789", "123纳尼456我屮艸芔茻789")
print(match.group("yoyoyo"), match.group("哈哈哈")) # 纳尼 我屮艸芔茻
print(match.group(1), match.group(2)) # 纳尼 我屮艸芔茻
# 并且使用组的序号依旧是可以的 # 除了group之外,还可以使用groupdict和groups
match = re.search(r"123(?P<yoyoyo>.+?)456(?P<哈哈哈>.+?)789", "123纳尼456我屮艸芔茻789")
print(match.groups()) # ('纳尼', '我屮艸芔茻')
print(match.groupdict()) # {'yoyoyo': '纳尼', '哈哈哈': '我屮艸芔茻'} # groups无论是否指定组名,都会获取到。但是groupdict只会获取指定组名的分组,比如说:
match = re.search(r"123(?P<yoyoyo>.+?)456(.+?)789", "123纳尼456我屮艸芔茻789")
print(match.groups()) # ('纳尼', '我屮艸芔茻')
# 可以看到没有指定组名的就获取不到了
print(match.groupdict()) # {'yoyoyo': '纳尼'} # 此外在分组的时候,还可以指定管道符|,表示或者。比如
# jpg|png表示获取的是jpg或者png,注意:管道符会作用于两边的全部字符,比如:
# www.mashiro.jpg|png,则表示的是www.mashiro.jpg或者png
# www.mashiro.(jpg|png),此时的管道符只会作用于括号里面两端的字符,表示www.mashiro.jpg或者www.mashiro.png
print(re.search(r"www\.mashiro\.(jpg|png)", "www.mashiro.jpg")) # <re.Match object; span=(0, 15), match='www.mashiro.jpg'>
# 注意这里的\.表示转义,让.表示普通的. 不是具有匹配字符能力的. # 但是这里又出现问题了,比如说
text = '''
这里有图片哦www.1.jpg,有很多格式的哦
www.2.png,想看吗,还会动哦,www.3.gif
那还等什么呢?www.banana.jpg,
快去吧,那个象征自由的男人在等着你www.象征自由的男人--尻比.png
'''
res = re.findall(r"www.+?(jpg|png|gif)", text)
print(res) # ['jpg', 'png', 'gif', 'jpg', 'png']
'''
可以看到findall获取的自动是分组里面的内容,可我们要的是整体的链接啊。怎么办呢?一种方法是我在外面也加上括号不就行了
''' res = re.findall(r"(www.+?(jpg|png|gif))", text)
print(res) # [('www.1.jpg', 'jpg'), ('www.2.png', 'png'), ('www.3.gif', 'gif'), ('www.banana.jpg', 'jpg'), ('www.象征自由的男人--尻比.png', 'png')]
# 可以看到最外层的分组也被我们所捕获了,多个分组的内容回族和成一个元组。因此可以使用索引获取链接,但这还不是最完美的方法。
# 有什么办法,让里面的那个分组失去效果呢?就是说,我给你加上括号只是为了多匹配一些格式罢了,你就不要自作聪明地当做分组来处理了
# 答案是有的,只需要加上?:即可,在括号里面加上?:表示让分组失去效果,也就是不表示分组
res = re.findall(r"www.+?(?:jpg|png|gif)", text)
print(res) # ['www.1.jpg', 'www.2.png', 'www.3.gif', 'www.banana.jpg', 'www.象征自由的男人--尻比.png']
# 可以看到匹配成功,而且此时最外层也不需要再加上括号了,因为里面的分组失去效果了,相当于就没有分组了,如果没有分组,那么默认匹配整体。 # 最后插一句,聊一聊www.+?(?:jpg|png|gif),为什么要是.+?呢,如果是.+行不行,比如:
print(re.search(r"www.+?jpg", "www.1.jpg我屮艸芔茻www.2.jpg").group()) # www.1.jpg
# 我把?去掉,那么等于变成了贪婪模式。
print(re.search(r"www.+jpg", "www.1.jpg我屮艸芔茻www.2.jpg").group()) # www.1.jpg我屮艸芔茻www.2.jpg
# 那么会从第一个www开始,匹配到最后一个jpg,因此要注意开启非贪婪模式

7.搜索选项

import re

'''
选项标志是用来改变匹配引擎处理表达式的方式。
比如说,我们可以看看re.search()的函数原型
def search(pattern, string, flags=0):
这个pattern和string我们都知道,但是最后一个参数flags是什么鬼?
这个flags就是选项标志,也是我们接下来要说的内容
''' # 大小写无关
'''
有些时候,我们不想区分大小写该怎么办呢?比如说aa和AA我们认为都是合法的。
'''
# 这便是flags的作用,可以用来改变引擎处理表达式的方式
# re.IGNORECASE表示忽略大小写敏感模式,其中re.IGNORECASE也可以写成re.I
match = re.match(r"aa", "aA", flags=re.IGNORECASE)
print(match) # <re.Match object; span=(0, 2), match='aA'> # 多行输入
'''
有两个标志会影响如何完成多行输入的搜索:MULTILINE和DOTALL。
MULTILINE表示^和*的锚定规则除了应用于整个字符串之外,还对每一行的开头和结尾起作用。(不常用)
DOTALL表示.这个元字符可以匹配换行符,默认情况下,.这个元字符是不能匹配换行符的,但是加上这个参数之后,便可以匹配换行符 注:re.MULTILINE可以写成re.M,re.DOTALL可以写成re.S
'''
match = re.match(r".+", "aabb\ncc")
print(match) # <re.Match object; span=(0, 4), match='aabb'>
match = re.match(r".+", "aabb\ncc", flags=re.DOTALL)
print(match) # <re.Match object; span=(0, 7), match='aabb\ncc'> # Unicode
'''
默认情况下,正则表达式处理的都是Unicode文本,也就是说\w是可以匹配中文的。
如果我想只匹配ASCII码呢?可以使用re.ASCII,这样的话就不会匹配中文了.
re.ASCII也可以写成re.A
'''
print(re.match(r"\w+", "love中国")) # <re.Match object; span=(0, 6), match='love中国'>
print(re.match(r"\w+", "love中国", flags=re.ASCII)) # <re.Match object; span=(0, 4), match='love'>

8.字符串替换

import re

'''
我们也可以将字符串进行一个替换
'''
text = "when i was young, i'd listen to the radio"
# 我要把当中所有的i替换成大写的I,怎么做呢?
# 可以使用re.sub函数,def sub(pattern, repl, string, count=0, flags=0):
# 参数:要替换的字符模式 替换成哪些字符 文本 替换的数量(默认为0,表示全部) 匹配模式
print(re.sub(r"i", "I", text)) # when I was young, I'd lIsten to the radIo # 我要把里面的英文全部删除
text = "古明地觉(komeiji satori)是一个来自于东方地灵殿的女孩,它有一个妹妹,叫古明地恋(komeiji koishi)"
# 把\w都替换成空即可,但是注意\w默认是匹配中文(以及日文等等)的,所以要加上flags=re.A,表示只匹配ASCII码中的字符
print(re.sub(r"\w", "", text, flags=re.A)) # 古明地觉( )是一个来自于东方地灵殿的女孩,它有一个妹妹,叫古明地恋( )
# 不加flags的话,会把中文也剥掉了
print(re.sub(r"\w", "", text)) # ( ),,( ) # 除此之外还有一个函数叫做subn,和sub一样,但是除了返回替换的内容,还会返回替换的数量
print(re.subn("a", "b", "accaccacc")) # ('bccbccbcc', 3)

9.利用模式拆分

import re

'''
类似于str.split,re也可以使用split函数,而且功能更加强大
'''
text = "abc1def55455ghi6621"
# 我要按照数字切割,最终只保留,abc def ghi该怎么做呢?
# 直接调用split即可, 此外还可以指定最多分割多少次,不指定默认为全部。这里表示用数字切割
print(re.split(r"\d", text)) # ['abc', 'def', '', '', '', '', 'ghi', '', '', '', '']
# 可以手动去掉空格
no_space = list(filter(lambda x: len(x), re.split(r"\d", text)))
print(no_space) # ['abc', 'def', 'ghi']

re:正则表达式,字符串处理的杀手锏的更多相关文章

  1. Python: 字符串搜索和匹配,re.compile() 编译正则表达式字符串,然后使用match() , findall() 或者finditer() 等方法

    1. 使用find()方法 >>> text = 'yeah, but no, but yeah, but no, but yeah' >>> text.find( ...

  2. [Python正则表达式] 字符串中xml标签的匹配

    现在有一个需求,比如给定如下数据: 0-0-0 0:0:0 #### the 68th annual golden globe awards #### the king s speech earns ...

  3. 2016/3/18 ①PHP基础 ② PHP函数 ③其他函数(随机数、关于日期) ④正则表达式 ⑤字符串处理

    一.PHP基础 1,标记和注释 ①<?php?> ②单行注释// 多行注释/**    */2, 输出语句 ①echo输出 echo可以输出多个字符串,用逗号隔开. ②print输出 pr ...

  4. Jquery对文本框的值、字符串的验证;正则表达式字符串的验证

    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/ ...

  5. Python(四)装饰器、迭代器&生成器、re正则表达式、字符串格式化

    本章内容: 装饰器 迭代器 & 生成器 re 正则表达式 字符串格式化 装饰器 装饰器是一个很著名的设计模式,经常被用于有切面需求的场景,较为经典的有插入日志.性能测试.事务处理等.装饰器是解 ...

  6. Day3_字符串操作与正则表达式

    本节课的主要内容有:字符串的格式化.连接与分割.比较.匹配和替换.使用正则表达式 字符串的格式化: 去除空格:trim() 使用html格式化:nl2br()  替换‘\n’为‘<br /> ...

  7. python字符串转义与正则表达式特殊字符转义

    最近在自学python,字符串和正则表达式的特殊字符转义有点混淆,做个笔记简单总结一下. 1.普通字符串转义 在字符串中使用特殊字符时,要用反斜杠(\)转义字符.例如:'Let\'s go!',这里对 ...

  8. Day 12 字符串和正则表达式

    使用正则表达式 正则表达式相关知识 在编写处理字符串的程序或网页时,经常会有查找符合某些复杂规则的字符串的需要,正则表达式就是用于描述这些规则的工具,换句话说正则表达式是一种工具,它定义了字符串的匹配 ...

  9. Python装饰器、迭代器&生成器、re正则表达式、字符串格式化

    Python装饰器.迭代器&生成器.re正则表达式.字符串格式化 本章内容: 装饰器 迭代器 & 生成器 re 正则表达式 字符串格式化 装饰器 装饰器是一个很著名的设计模式,经常被用 ...

随机推荐

  1. Message 消息提示

    常用于主动操作后的反馈提示.与 Notification 的区别是后者更多用于系统级通知的被动提醒. 基础用法 从顶部出现,3 秒后自动消失. Message 在配置上与 Notification 非 ...

  2. gimp怎么移动选取中的图像并创建图层

    gimp怎么移动选取中的图像并创建图层 https://jingyan.baidu.com/article/414eccf6bf4d6e6b431f0a3b.html 听语音 原创 | 浏览:1148 ...

  3. 引入easyui的404问题

    直接在webapp创建css文件夹添加easyui 引入: <link rel="stylesheet" type="text/css" href=&qu ...

  4. 强大的BeautifulSoup

    Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库·它能够通过你喜欢的转换器实现惯用的文档导航 安装BeautifulSoup 推荐使用Beautiful Sou ...

  5. JavaScript基本入门03

    目录 JavaScript 入门基础 03 JavaScript构造函数 常用事件和事件处理函数 小练习 数据类型之间的差异性 数组 介绍 创建 数组的常规使用 数组的length属性 数组当中常见的 ...

  6. python 将视频转换成音频

    安装库 sudo pip install moviepy 代码 index.py from moviepy.editor import * video = VideoFileClip('test.mp ...

  7. JWT With NetCore WebApi

    1 什么是JWT? JWT是一种用于双方之间传递安全信息的简洁的.URL安全的表述性声明规范.JWT作为一个开放的标准(RFC 7519),定义了一种简洁的,自包含的方法用于通信双方之间以Json对象 ...

  8. Android测试之查看package和activity名称的方法

    方法一:使用aapt    //aapt是sdk自带的一个工具,在sdk\builds-tools\目录下 1.命令行中切换到aapt.exe目录执行:aapt dump badging + 路径  ...

  9. easyui datagrid checkbox复选框取消单击选中事件、初始全选全不选等问题解决

    系统业务需要,导入的列表数据默认全部选中,且不可取消选中行.全部店铺优惠券发放过后导入的数据全部清空.如图所示: 一.初始化页面默认全部选中“selectAll”,全部不选中“unselectAll” ...

  10. POJ3734 Block母函数入门

    一段长度为n的序列,你有红黄蓝绿四种颜色的砖块,一块砖长度为1,问你铺砖的方案数,其中红黄颜色之和必须为偶数. #include <queue> #include <stack> ...