正则表达式

#!/usr/bin/env python

# -*- coding: utf-8 -*-

# @Time    : 2018/7/26 16:39

# @Author  : jackendoff

# @Site    :

# @File    : 正则学习.py

# @Software: PyCharm

# re模块的使用过程

import re

# '''

# re模块的使用过程

# re.match(pattern, string, flags=0)

# 从头匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None

#  · pattern: 正则模型

#  · string： 要匹配的字符

#  · flags： 匹配模式

#  这个方法并不是完全匹配，当pattern结束时若string还有剩余字符，仍视为成功，想要完全匹配，可以在表达式末尾加上边界匹配符‘$’

# '''

# result = re.match('^\d{3}$', '124')

# print(result.group())  # 返回被re匹配的字符串124

# print(result.start())  # 返回匹配开始的位置0

# print(result.end())  # 返回匹配结束的位置3

# print(result.span())  # 返回一个元组包含匹配（开始，结束）的位置(0, 3)

'''

re.search函数会在字符串内查找模式匹配，只要找到第一个匹配然后返回，如果字符串没有匹配，则返回None

格式：re.search(pattern, string, flags=0)

match()和search()的区别：

match()函数只检测re是不是在string的开始位置匹配，search()会扫描

整个string查找匹配；

也就是说match()只有在0位置匹配成功的化才有返回，如果不是开始位置匹配成功的话，match()就返回none。

'''

# import re

# ret = re.search(r'\d+', '阅读次数为9999')

# print(ret.group())  # 运行结果9999

#

# print(re.match('super', 'superstition').span())  # 结果(0, 5)

# print(re.match('super', 'insuperstition'))  # 结果None

# print(re.search('super', 'superstition').span())  # 结果(0, 5)

# print(re.search('super', 'insuperstition').span())  # 结果(2, 7)

'''

re.findall遍历匹配，可以获取字符串中所有匹配字符串，返回一个列表

'''

# import re

#

# ret = re.findall(r'\d+', '阅读次数：9999次，转发次数：887次，评论次数：3次')

# print(ret)  # 运行结果['9999', '887', '3']

'''

sub将匹配到的数据进行替换

使用re替换string中每一个匹配的字符串后返回替换后的字符串

格式：re.sub(pattern, repl, string,count)

'''

# import re

#

# ret = re.sub(r'\d+', '10000', '阅读次数：9999次， 转发次数：883次， 评论次数：3次')

# print(ret)  # 运行结果 阅读次数：10000次， 转发次数：10000次， 评论次数：10000次

import re

# def add(temp):

#     strNum = temp.group()

#     print(strNum)  # 运行结果997

#     num = int(strNum) + 1

#     return str(num)  # 返回一个字符串

# ret = re.sub(r'\d+', add, 'python = 997')  # 可以分解为result = re.search(r'\d+', 'python=997') --》add(result)

# print(ret)  # 运行结果python = 998

#

# ret = re.sub(r'\d+', add, 'python = 99')

# print(ret)  # 运行结果python = 100

'''

import re

def add(temp):

    strNum = temp.group()

    print(strNum)  # 运行结果997

    num = int(strNum) + 1

    return str(num)

result = re.search(r'\d+', 'python=997')

print(add(result))

'''

'''

split根据匹配进行切割字符串，并返回一个列表

按照能够匹配的字符串string分割都返回列表。

可以使用re.split来分割字符串

格式：re.split(pattern, string[,maxspit])

'''

import re

ret = re.split(r":| ", 'info:xiaozhang 33 shandong')

print(ret)  # 运行结果 ['info', 'xiaozhang', '33', 'shandong']

'''

pyhton里数量词默认是贪婪的，总是尽可能多地匹配字符；

非贪婪则相反，总是尝试匹配尽可能少的字符

在'*','+','?','{m, n}后面加上？，使贪婪变为非贪婪。'

'''

　　

量词：

　　* 重复0次或更多次

　　+ 重复一次或更多次

　　？重复0次或一次

　　{n} 重复n次

　　{n,} 重复n次或更多次

　　{n,m} 重复n到m次

　　贪心匹配（默认）

　　惰性匹配： 量词 + ''?''

　　.*?x 前面取任意长度字符直到取到x

字符：

　　. 匹配除换行以外的任意字符

　　\w 匹配字母或数字或下划线

　　\d 匹配数字(digit)

　　\s 匹配任意空白符（space）

　　\n 匹配一个换行符

　　\t 匹配一个制表符（TAB）

　　\b 匹配一个单词的结尾

　　^ 匹配字符串的开始

　　$ 匹配字符串的结尾

　　\W 匹配非字母或数字或下划线

　　\D 匹配非数字

　　\S 匹配非空白符

　　a|b 匹配字符a或者字符b

　　( ) 匹配括号内的表达式，也表示一个组（search）

　　[...] 匹配字符组中的字符

　　[^...] 匹配除字符组以外的所有字符

pyhton re模块

python正则

 #!/usr/bin/env python

 # -*- coding: utf-8 -*-

 # @Time    : 2018/7/8 9:27

 # @Author  : jackendoff

 # @Site    :

 # @File    : text.py

 # @Software: PyCharm

 import re

 # find_str = re.findall('a', 'jai jack')  # 匹配所有，并显示所有

 # print(find_str)

 #

 # search_str = re.search('a', 'jia jack')  # 匹配找到的第一个，并显示

 # print(search_str)

 # search_gp = search_str.group()

 # print(search_gp)

 #

 # match_str = re.match('a', 'a bc')  # 匹配第一个

 # print(match_str)

 # match_gp = match_str.group()

 # print(match_gp)

 #

 # find_str = re.findall('[a-z]\d', 'ji58a991')  # 匹配a-z和数字

 # print(find_str)

 # find_str = re.findall('([a-z])\d', 'ji58a991')  # 匹配a-z和数字

 # print(find_str)

 # find_str = re.findall('(?:[a-z])\d', 'ji58a991')  # ()代表‘组’在findall里优先显示  '?:'代表‘取消优先’

 # print(find_str)

 #

 # search_str = re.search('([a-z])(\d)', 'jia123nfdj8684')  # 匹配a-z和数字 分组

 # search_gpp = search_str.group()  # 显示匹配的数字和字母

 # print(search_gpp)

 # search_gp = search_str.group(1)  # 显示第一个组

 # print(search_gp)

 # search_gp = search_str.group(2)  # 显示第二个组

 # print(search_gp)

 # sp_str = re.split('\d', 'jia4jfa5f78a')  # 依据数字分割

 # print(sp_str)

 # split_str = re.split('[a1]', 'jiafd54f1k')  # 先根据a分割，仔根据1分割

 # print(split_str)

 #

 # sub_str = re.sub('[\d]', '0', 'jia123fd6', 2)  # 将数字替换成0，2表示只替换两个

 # print(sub_str)

 # sub_str = re.subn('[\d]', '0', 'jia123fd6')  # 将数字替换成0，返回一个元组（替换的结果，替换了多少次）

 # print(sub_str)

 # obj = re.compile('\d{3}')  # 将正则表达式编译成一个正则对象（当表达式特别复杂的时候此对象可以多次使用）匹配三个数字

 # obj_str = obj.search('jia123kill')  # 直接使用对象调用search进行匹配

 # o_str = obj_str.group()

 # print(o_str)

 # ret = re.finditer('\d', 'jia5fd55fs6f5')  # finditer返回一个存放匹配结果的迭代器（节省内存)

 # print(ret)

 # # for i in ret:

 #     print(i.group())

正则案例，windows命令行  超多

1. 初步使用

In [1]: import re

In [11]: re.match(r"abc","abcde").group()

In [12]: re.match(r"bc","abcde").group()

In [14]: re.search(r"bc","abcde").group()

2. 匹配单个字符

-----------------------.匹配任意字符(除\n)-------------------------------

In [5]: re.match(r".","A").group()

In [6]: re.match(r".","a").group()

In [7]: re.match(r".",".").group()

In [8]: re.match(r".","\n").group()

In [9]: re.match(r".","x").group()

In [10]: re.match(r"A.C","ABC").group()

-------------------------[]匹配集合中任何一个字符---------------------------

In [11]: re.match(r"[aA]BC","ABC").group()

In [12]: re.match(r"[aA]BC","aBC").group()

In [13]: re.match(r"[aA]BC","xBC").group()

In [14]: re.match(r"[0123456789]BC","1BC").group()

In [15]: re.match(r"[0123456789]BC","9BC").group()

-------------------------[-]表示范围-----------------------------

In [16]: re.match(r"[0-9]BC","9BC").group()

In [17]: re.match(r"[0-9]BC","2BC").group()

In [18]: re.match(r"[0-9a-zA-Z]BC","ABC").group()

In [19]: re.match(r"[0-9a-zA-Z]BC","aBC").group()

In [21]: re.match(r"[0-9a-zA-Z]BC","&BC").group()

In [22]: re.match(r"[0-35-9]BC","1BC").group()

In [24]: re.match(r"[0-35-9]BC","4BC").group()

-------------------------[^]对匹配范围取反-----------------------------

In [25]: re.match(r"[^4]BC","4BC").group()

In [26]: re.match(r"[^4]BC","1BC").group()

In [27]: re.match(r"[^4]BC","9BC").group()

In [28]: re.match(r"[^4a-z]BC","aBC").group()

In [29]: re.match(r"[^4a-z]BC","zBC").group()

In [30]: re.match(r"[^4a-z]BC","ZBC").group()

-------------------------\d匹配数字字符 \D匹配非数字---------------------

In [31]: re.match(r"[0-9]BC","4BC").group()

In [32]: re.match(r"\dBC","4BC").group()

In [33]: re.match(r"\dBC","2BC").group()

In [34]: re.match(r"\DBC","2BC").group()

In [35]: re.match(r"\DBC","aBC").group()

In [36]: re.match(r"\DBC","xBC").group()

--------------------------\w匹配单词字符 \w匹配非单词------------------------

In [38]: re.match(r"\wBC", "ABC").group()

In [39]: re.match(r"\wBC", "aBC").group()

In [40]: re.match(r"\wBC", "1BC").group()

In [41]: re.match(r"\wBC", "_BC").group()

In [42]: re.match(r"[\da-zA-Z_]BC", "1BC").group()

In [43]: re.match(r"[\da-zA-Z_]BC", "ABC").group()

In [44]: re.match(r"[\da-zA-Z_]BC", "aBC").group()

In [45]: re.match(r"[\da-zA-Z_]BC", "_BC").group()

In [46]: re.match(r"\WBC", "_BC").group()

In [47]: re.match(r"\WBC", "$BC").group()

In [48]: re.match(r"\WBC", " BC").group()

3. 匹配多个字符

In [50]: re.match(r"嫦娥\w号", "嫦娥一号升空了", re.A).group()

In [51]: re.match(r"嫦娥\d号", "嫦娥1号升空了", re.A).group()

In [52]: re.match(r"嫦娥\d\d号", "嫦娥11号升空了", re.A).group()

In [53]: re.match(r"嫦娥\d\d\d号", "嫦娥111号升空了", re.A).group()

In [54]: re.match(r"嫦娥\d\d\d\d\d\d号", "嫦娥111111号升空了", re.A).group()

In [55]: re.match(r"嫦娥\d{6}号", "嫦娥111111号升空了", re.A).group()

In [56]: re.match(r"嫦娥\d{6}号", "嫦娥11号升空了", re.A).group()

In [57]: re.match(r"嫦娥\d{2,6}号", "嫦娥11号升空了", re.A).group()

In [58]: re.match(r"嫦娥\d{2,6}号", "嫦娥11111号升空了", re.A).group()

In [59]: re.match(r"嫦娥\d{1,}号", "嫦娥11111号升空了").group()

In [60]: re.match(r"嫦娥\d{1,}号", "嫦娥11111111111号升空了").group()

In [61]: re.match(r"嫦娥\d+号", "嫦娥11111111111号升空了").group()

In [63]: re.match(r"嫦娥\d+号", "嫦娥号升空了").group()

In [64]: re.match(r"嫦娥\d{0,}号", "嫦娥号升空了").group()

In [65]: re.match(r"嫦娥\d{0,}号", "嫦娥1111号升空了").group()

In [66]: re.match(r"嫦娥\d*号", "嫦娥1111号升空了").group()

In [67]: re.match(r"嫦娥\d*号", "嫦娥号升空了").group()

In [81]: re.match(r"嫦娥\d{0,1}号", "嫦娥号升空了").group()

In [82]: re.match(r"嫦娥\d{0,1}号", "嫦娥1号升空了").group()

In [83]: re.match(r"嫦娥\d?号", "嫦娥1号升空了").group()

In [84]: re.match(r"嫦娥\d?号", "嫦娥11号升空了").group()

4. 匹配开始和结束位置

	.在正则中表示匹配除\n之外的任意字符  如果要再正则中表示.本身的含义 使用\.

In [68]: re.match(r"\w@163.com","123456@163.com").group()

In [69]: re.match(r"\w{4,20}@163.com","123456@163.com").group()

In [70]: re.match(r"\w{4,20}@163.com","123456@163Acom").group()

In [71]: re.match(r"\w{4,20}@163\.com","123456@163Acom").group()

In [72]: re.match(r"\w{4,20}@163\.com","123456@163.com").group()

In [73]: re.match(r"\w{4,20}@163\.com","123456@163.com.cc").group()

In [74]: re.match(r"\w{4,20}@163\.com",".ccc.123456@163.com").group()

In [75]: re.match(r"\w{4,20}@163\.com","123456@163.com.cc").group()

In [76]: re.match(r"\w{4,20}@163\.com$","123456@163.com.cc").group()

In [77]: re.search(r"\w{4,20}@163\.com$","123456@163.com.cc").group()

In [78]: re.search(r"\w{4,20}@163\.com$","ccc.123456@163.com").group()

In [79]: re.match(r"\w{4,20}@163\.com$","ccc.123456@163.com").group()

In [80]: re.search(r"^\w{4,20}@163\.com$","ccc.123456@163.com").group()

In [81]: re.search(r"^\w{4,20}@163\.com$","123456@163.com").group()

5. 分组

----------------------()将感兴趣的数据放到分组中-------------------------

In [86]: re.match(r"嫦娥\d+号", "嫦娥9号升空了").group()

In [87]: re.match(r"嫦娥(\d+)号", "嫦娥9号升空了").group()

In [88]: re.match(r"嫦娥(\d+)号", "嫦娥9号升空了").group(0)

In [89]: re.match(r"嫦娥(\d+)号", "嫦娥9号升空了").group(1)

In [90]: re.search(r"(^\w{4,20})@163\.com$","123456@163.com").group(1)

In [91]: re.search(r"(^\w{4,20})@(163)\.com$","123456@163.com").group(1)

In [92]: re.search(r"(^\w{4,20})@(163)\.com$","123456@163.com").group(2)

----------------------|匹配左右任何一个正则表达式--------------------------

In [93]: re.search(r"(^\w{4,20})@163\.com$|^\w{4,20}@qq\.com$","123456@163.com").group(1)

In [94]: re.search(r"(^\w{4,20})@163\.com$|^\w{4,20}@qq\.com$","123456@163.com").group(0)

In [95]: re.search(r"(^\w{4,20})@163\.com$|^\w{4,20}@qq\.com$","123456@qq.com").group(0)

---------------------(|)匹配()中任何一个正则表达式并将匹配结果放到分组中-------

In [96]: re.search(r"(^\w{4,20})@(163|qq)\.com$","123456@qq.com").group(0)

In [97]: re.search(r"(^\w{4,20})@(163|qq)\.com$","123456@163.com").group(0)

In [98]: re.search(r"(^\w{4,20})@(163|qq)\.com$","123456@263.com").group(0)

In [99]: re.search(r"(^\w{4,20})@(163|qq|263)\.com$","123456@263.com").group(0)

In [100]: re.search(r"(^\w{4,20})@(163|qq|263|126)\.com$","123456@263.com").group(0)

In [101]: re.search(r"(^\w{4,20})@(163|qq|263|126)\.com$","123456@263.com").group(1)

In [102]: re.search(r"(^\w{4,20})@(163|qq|263|126)\.com$","123456@263.com").group(2)

---------------------引用分组(匿名 只能通过分组号引用)--------------------------------

In [103]: re.match(r"<\w+>.*", "<html>hh</html>").group()

In [104]: re.match(r"<(\w+)>.*", "<html>hh</html>").group()

In [105]: re.match(r"<(\w+)>.*", "<html>hh</html>").group(1)

In [106]: re.match(r"<(\w+)>.*</\1>", "<html>hh</html>").group(1)

In [107]: re.match(r"<(\w+)>.*</\1>", "<html>hh</htm>").group(1)

In [108]: re.match(r"<(\w+)><(\w+)>(.*)</\2></\1>", "<html><h1>www.itcast.cn</h1></html>").group(1)

In [109]: re.match(r"<(\w+)><(\w+)>(.*)</\2></\1>", "<html><h1>www.itcast.cn</h1></html>").group()

In [110]: re.match(r"<(\w+)><(\w+)>(.*)</\2></\1>", "<html><h1>www.itcast.cn</h2></html>").group()

In [111]: re.match(r"(\d{3,4})-(\d{6,8})", "010-12345678").group(1)

In [112]: re.match(r"(\d{3,4})-(\d{6,8})", "010-12345678").group(2)

In [113]: re.match(r"((\d{3,4})-(\d{6,8}))", "010-12345678").group(2)

In [114]: re.match(r"((\d{3,4})-(\d{6,8}))", "010-12345678").group(1)

In [115]: re.match(r"((\d{3,4})-(\d{6,8}))", "010-12345678").group(3)

------------------创建有名分组 给分组起名  使用有名分组------------------------

In [116]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}))", "010-12345678").group(3)

In [118]: re.match(r"(?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group()

In [119]: re.match(r"(?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(1)

In [120]: re.match(r"(?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(2)

In [121]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(2)

In [122]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(1)

In [123]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(2)

In [124]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(3)

6. 高级函数

----------------------------------------------------------------------------

In [127]: ret = re.match(r"\d+", "阅读次数为 9999").group()

In [129]: ret = re.search(r"\d+", "阅读次数为 9999").group()

In [131]: re.search(r"\d+", "阅读次数为 9999").group()

----------------------------------------------------------------------------

In [132]: re.findall(r"\d+", "阅读次数为 9999").group()  # 不可以用.group()

In [133]: re.findall(r"\d+", "阅读次数为 9999")

In [134]: re.findall(r"\d+", "阅读次数为")  # 没匹配到返回空列表

----------------------------------------------------------------------------

In [135]: re.sub(r"\d+","999", "python=666")

In [136]: re.sub(r"\d+","999", "python=666 cpp=688")

In [137]: re.sub(r"\d+","999", "python=666 cpp=688", 1)

In [138]: re.sub(r"\d+","999", "python=666 cpp=688")

In [139]: def add(matchobj):

     ...:     data = matchobj.group()

     ...:     number = int(data) + 1000

     ...:     return str(number)

In [140]: re.sub(r"\d+",add, "python=666 cpp=688")

In [141]: data = """

     ...: <div>

     ...:         <p>岗位职责：</p>

     ...: <p>完成推荐算法、数据统计、接口、后台等服务器端相关工作</p>

     ...: <p><br></p>

     ...: <p>必备要求：</p>

     ...: <p>良好的自我驱动力和职业素养，工作积极主动、结果导向</p>

     ...: <p> <br></p>

     ...: <p>技术要求：</p>

     ...: <p>1、一年以上 Python 开发经验，掌握面向对象分析和设计，了解设计模式</p>

     ...: <p>2、掌握HTTP协议，熟悉MVC、MVVM等概念以及相关WEB开发框架</p>

     ...: <p>3、掌握关系数据库开发设计，掌握 SQL，熟练使用 MySQL/PostgreSQL 中的一种<br></p>

     ...: <p>4、掌握NoSQL、MQ，熟练使用对应技术解决方案</p>

     ...: <p>5、熟悉 Javascript/CSS/HTML5，JQuery、React、Vue.js</p>

     ...: <p> <br></p>

     ...: <p>加分项：</p>

     ...: <p>大数据，数理统计，机器学习，sklearn，高性能，大并发。</p>

     ...:

     ...:         </div>"""

In [142]: re.sub(r"<\w+>","",data)

In [143]: re.sub(r"<\w+>|\n","",data)

In [144]: re.sub(r"<\w+>|\n|</\w+>","",data)

In [145]: re.sub(r"</?\w+>|\n|","",data)

In [146]: re.sub(r"</?\w+>|\n| ","",data)

7. 贪婪模式和非贪婪模式<>

----------------------------------------------------------------------------

In [147]: re.split(r"\s","123456_abcdef ghjkl\t12312312")

In [148]: re.split(r"\s|_","123456_abcdef ghjkl\t12312312")

In [149]: re.search(r"\d+", "嫦娥199999号升空了")

In [150]: re.search(r"\d+", "嫦娥1999999999号升空了").group()

In [151]: re.search(r"\d+\d+", "1999999999").group()

In [152]: re.search(r"(\d+)(\d+)", "1999999999").group()

In [153]: re.search(r"(\d+)(\d+)", "1999999999").group(1)

In [154]: re.search(r"(\d+)(\d+)", "1999999999").group(2)

In [155]: re.search(r"(\d+?)(\d+)", "1999999999").group(2)

In [156]: re.search(r"(\d+?)(\d+)", "1999999999").group(1)

In [157]: url = """<img data-original="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_2016111319

     ...: 17_small.jpg" src="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.j

     ...: pg" style="display: inline;">

     ...: """

In [158]: re.search(r"https:.*\.jpg",url).group()

In [159]: re.search(r"https:.*?\.jpg",url).group()

8 r标识原生字符串

----------------------------------------------------------------------------

In [160]: path = "c:\a\b\c"

In [161]: path

Out[161]: 'c:\x07\x08\\c'

In [162]: print(path)

c\c

In [163]: path = "c:\\a\\b\\c"

In [164]: path

Out[164]: 'c:\\a\\b\\c'

In [165]: path = "c:\\a\\b\c"

Out[166]: 'c:\\a\\b\\c'

In [167]: re.match("c:\\a",path).group()

In [168]: re.match(r"c:\\a",path).group()

In [169]: re.match("c:\\\\a",path).group()

In [170]: re.match("c:\\\\a\\\\b",path).group()

In [171]: re.match("c:\\\\a\\\\b\\\\c",path).group()

In [172]: re.match(r"c:\\a\\b\\c",path).group()

　　

最新文章

  1. 【Effective Java】9、使用EnumMap代替序数索引
  2. JavaScript OOP 之「创建对象」
  3. entity framework 新手入门篇（1）-建立模型
  4. JAVA&#160;SSH&#160;框架介绍
  5. js笔记——js里var与变量提升
  6. CentOS 7 编译安装 Code::Blocks
  7. C# Socket服务器端如何判断客户端断开
  8. poj3589---判断两个数有多接近
  9. TextView textSize 文字大小
  10. NET 2016
  11. WebStorm10 控制台中文乱码解决方案
  12. C语言博客作业—一二维数组
  13. mysql 重点性能测试指标
  14. js 数字随机滚动(数字递增) 每日凌晨回到原点,重新计算
  15. 棒槌的工作第八天-----------------------早会-------三次握手四次挥手（转载https://www.cnblogs.com/zmlctt/p/3690998.html）尚待了解，下班补充
  16. JavaScript Date 对象的异常现象-new Date(&#39;0001-01-01 00:00:00&#39;)
  17. js实现的map方法
  18. 关于java Collections.sort 排序
  19. Gym .101933 Nordic Collegiate Programming Contest (NCPC 2018) (寒假gym自训第四场)
  20. mybatis自动生成代码，逆向工程

热门文章

  1. 51Nod1085 0-1背包（一维和二维数组实现）
  2. Android自定义View——彩色圆环统计图
  3. 201771010123汪慧和《面向对象程序设计Java》第十七周实验总结
  4. WebView的学习
  5. POJ 2828 线段树活用
  6. UML-活动图及其建模
  7. python编程：从入门到实践----第六章&gt;字典
  8. go多态
  9. Linux(CENTOS7) Redis安装
  10. Spring Cloud Alibaba 教程 | Nacos（六）