笔记：正则表达式

最新推荐文章于 2024-06-17 19:39:11 发布
最新推荐文章于 2024-06-17 19:39:11 发布
阅读量238 收藏
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/v_12138/article/details/79052334
版权

正则表达式

正则表达式（regex）：一些由字符和特殊符号组成的字符串。（A~Z,a~z）
匹配--->matching   模式匹配--->pattern-matching   搜索--->searching

特殊符号和字符

并（union）或者逻辑或（logical OR）（|） ： 从多个模式中选择其一，匹配多个字符
点号或者句点（.） ： 匹配任意单个字符（\n除外）
注：匹配句点（dot）或句号（period）字符--->（\.）
脱字符（^）或者特殊字符（\A）：匹配字符串的开始位置
美元符号（$）或者（\Z）：匹配字符串的末尾位置
特殊字符（\b）（\B）：匹配字符边界
方括号（[]）：匹配一对方括号中包含的任意字符
（[ - ]）：匹配指定字符范围
（[^ - ]）：不匹配给定字符集中任何一个字符
星号或者星号操作符（*）：匹配其左边的正则表达式出现零次或多次的情况（Kleene必包）
加号（+）操作符：匹配一次或许多次出现的正则表达式（正闭包操作符）
问号（？）操作符：匹配一次或者零次出现的正则表达式
大括号操作符（{单个值/一对由逗号分割的值}）：匹配前面正则表达式或者一定范围的次数
d：匹配任何十进制数字                        \D：表示任何非十进制数
\w：表示全部字母数字的字符集
\s：表示空格字符
圆括号（）：对正则表达式进行分组，匹配子组
（？…）：扩展表示法

re模块：核心函数和方法

正则表达式对象（regex object）  正则匹配对象（regex match object）

re.compile()（预编译）

使用任何可选的标记来编译正则表达式的模式，然后返回一个正则表达式对象
re.I、reIGNORECASE：不区分大小写的匹配
re.L、reLOCALE：根据所使用的本地语言环境通过\w、\W、\b、\B、\s、\S实现匹配
re.M、reMULTILINE：^和$分别匹配目标字符串中行的起始和结尾，而不是严格匹配整个字符串的开始和结尾
re.S、rer.DOTALL：“.”通常匹配除了\n之外所有单个字符；该标记表示“.”能够匹配全部字符
reX、re.VERBOSE：通过反斜线转义，否则所有空格加上#（以及在该行中所有后续文字）都被忽略，除非在一个字符类中或者允许注释并且提高可读性

search()（编译）

在任意位置对给定正则表达式模式搜索第一次出现的匹配情况，如果搜索到成功的匹配，就会返回一个匹配对象，否则，返回None 
>>> m=re.match('foo','seafod')
>>> if m is not None:m.group()

>>> m=re.search('foo','seafood')
>>> if m is not None :m.group()

'foo'

match() （编译）

从字符串的起始部分对模式进行匹配，如果匹配成功，就返回匹配对象，如果匹配失败，就返回None
group()：要么返回整个匹配对象，要么根据要求返回特定子组
groups()：仅返回一个包含唯一或者全部子组的元 
>>> import re
>>> m=re.match('foo','foo')
>>> if m is not None:
	m.group()

	
'foo'
>>> m
<_sre.SRE_Match object; span=(0, 3), match='foo'>

>>> m=re.match('foo','bar')
>>> if m is not None:
	m.group()

>>> m=re.match('foo','food on the table')
>>> m.group()
'foo'
>>>
>>> re.match('foo','food on the table').group()
'foo' 
 匹配多个字符： 

 

 
 
>>> bt='bat|bet|bit'
>>> m=re.match(bt,'bat')
>>> if m is not None:m.group()

'bat'
>>> m=re.match(bt,'blt')
>>> if m is not None:m.group()

>>> m=re.match(bt,'he bit me')
>>> if m is not None:m.group()

>>> m=re.search(bt,'he bit me')
>>> if m is not None:m.group()

'bit'
 匹配任何单一字符： 

 

 
 
>>> anyend='.end'
>>> m=re.match(anyend,'bend')
>>> if m is not None:m.group()

'bend'
>>> m=re.match(anyend,'end')
>>> if m is not None:m.group()

>>> m=re.match(anyend,'\nend')
>>> if m is not None:m.group()

>>> m=re.search('.end','the end')
>>> if m is not None:m.group()

' end'
 
 
>>> patt314='3.14'
>>> pi_patt='3\.14'
>>> m=re.match(pi_patt,'3.14')
>>> if m is not None:m.group()

'3.14'
>>> m=re.match(patt314,'3.14')
>>> if m is not None:m.group()

'3.14'
>>> m=re.match(patt314,'3014')
>>> if m is not None:m.group()

'3014'
 创建字符集（[]） 

 

 
 
>>> m=re.match('[cr][23][dp][o2]','c3po')
>>> if m is not None:m.group()

'c3po'
>>> m=re.match('[cr][23][dp][o2]','c2do')
>>> if m is not None:m.group()

'c2do'
>>> m=re.match('r2d2|c3po','c2do')
>>> if m is not None:m.group()

>>> m=re.match('r2d2|c3po','r2d3')
>>> if m is not None:m.group()
 重复、特殊字符异己分组： 

 

 
 
>>> patt='\w+@(\w+\.)?\w+\.com'
	     
>>> re.match(patt,'nobody@xxx.com').group()
	     
'nobody@xxx.com'
>>> patt='\w+@(\w+\.)?\w+\.com'
	     
>>> re.match(patt,'nobody@www.xxx.com').group()
	     
'nobody@www.xxx.com'
 
 
>>> patt='\w+@(\w+\.)*\w+\.com'
	     
>>> re.match(patt,'nobody@xxx.www.eee.rrr.com').group()
	     
'nobody@xxx.www.eee.rrr.com'
 
 
>>> m=re.match('\w\w\w-\d\d\d','abc-123')
	     
>>> if m is not None:m.group()

	     
'abc-123'
>>> m=re.match('\w\w\w-\d\d\d','abc-xyz')
	     
>>> if m is not None:m.group()



 
 
>>> m=re.match('(\w\w\w)-(\d\d\d)','abc-123')
	     
>>> m.group()
	     
'abc-123'
>>> m.group(1)
	     
'abc'
>>> m.group(2)
	     
'123'
>>> m.groups()
	     
('abc', '123')
 
 
>>> m.groups()
	     
('abc', '123')
>>> m=re.match('re','re')
	     
>>> m.group()
	     
're'
>>> m.groups()
	     
()
 
 
>>> m=re.match('(ab)','ab')
	     
>>> m.group()
	     
'ab'
>>> m.groups()
	     
('ab',)
>>> m=re.match('(a)(b)','ab')
	     
>>> m.group()
	     
'ab'
>>> m.groups()
	     
('a', 'b')
>>> m.group(1)
	     
'a'
>>> m.group(2)
	     
'b'

 
 
>>> m=re.match('(a(b))','ab')
	     
>>> m.group()
	     
'ab'
>>> m.group(1)
	     
'ab'
>>> m.group(2)
	     
'b'
>>> m.groups()
	     
('ab', 'b')

 匹配字符串的起始和结尾以及单词边界 

 

 
 
>>> m=re.search('^the','the end.')
	     
>>> if m is not None:m.group()

	     
'the'
>>> m=re.search('^the','end the')
	     
>>> if m is not None:m.group()

 
 
>>> m=re.search('\dthe','bite the dog')
	     
>>> if m is not None:m.group()


	     
>>> m=re.search(r'\dthe','bite the dog')
	     
>>> if m is not None:m.group()


	     
>>> m=re.search(r'\bthe','bitethedog')
	     
>>> if m is not None:m.group()


	     
>>> m=re.search(r'\Bthe','bitthe dog')
	     
>>> if m is not None:m.group()


	     
'the'

 使用findall()和finditer()查找每一次出现的位置： 

 

 
 
>>> re.findall('car','car')
	     
['car']
>>> re.findall('car','scary')
	     
['car']
>>> re.findall('car','carry the barcardi ti the car')
	     
['car', 'car', 'car']
 
 
>>> re.findall(r'(th\w+) and (th\w+)',s,re.I)
	     
[('this', 'that')]

 使用sub()和subn()搜索与替换 

 

 
 
>>> re.sub('X','Mr.Smith','attn:X\n\nDear X,\n')
	     
'attn:Mr.Smith\n\nDear Mr.Smith,\n'
>>> re.subn('X','Mr.Smith','attn:X\n\nDear X,\n')
	     
('attn:Mr.Smith\n\nDear Mr.Smith,\n', 2)
 
 
>>> re.sub('[ae]','X','abcdef')
	     
'XbcdXf'
>>> re.subn('[ae]','X','abcdef')
	     
('XbcdXf', 2)

 
 
>>> re.sub(r'(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})',
	   r'\2/\1/\3','2/20/1991')
	     
'20/2/1991'
>>> re.sub(r'(\d{1,2})/(\d{1,2})/(\d{2}|\d{4})',
	   r'\2/\1/\3','2/20/91')
	     
'20/2/91'

 在限定分模式上使用split()分割字符串： 
 
 
 
>>> re.split(':','str1:str2:str3')
	     
['str1', 'str2', 'str3']
 
 
>>> import re #简单解释器
	
>>> DATA=(
	'Mountain View,CA 94040',
	'Sunnyvale,CA',
	'Los Altos,94023',
	'Cupertino 95014',
	'Palo AC',
	)
	
>>> for datum in DATA:
	     print (re.split(', |(?= (?:\d{5}|[A-Z]{2})) ',datum))


	
['Mountain View,CA', '94040']
['Sunnyvale,CA']
['Los Altos,94023']
['Cupertino', '95014']
['Palo', 'AC']

 扩展符号： 

 

 
 
>>> re.findall(r'(?i)yes','yes? Yes. YES!!')#实现多行混合
	
['yes', 'Yes', 'YES']
>>> re.findall(r'(?i)th\w+','The auickest way is through this tunnel.')
	
['The', 'through', 'this']
>>> re.findall(r'(?im)(^th[\w ]+)', """)
This line is the first,
another line,
that line,it's the best
""")
	
['This line is the first', 'that line']
 
 
>>> re.findall(r'th.+','''
The first line
the second line
the third line
''')
	
['the second line', 'the third line']
>>> re.findall(r'(?s)th.+','''
The first line
the second line
the third line
''')
	
['the second line\nthe third line\n']

 
 
>>> re.search(r'''(?x)
\((\d{3})\)
[ ]
(\d{3})
-
(\d{4})
''','(800) 555-1212').groups()
('800', '555', '1212')

 
 
re.findall(r'http://(?:\w+\.)*(\w+\.com)',
'http://google.com http://www.google.com http://code.google.com')
['google.com', 'google.com', 'google.com']

 
 
re.search(r'\((?P<areacode>\d{3})\) (?P<prefix>\d{3})-(?:\d{4})',
'(800) 555-1212').groupdict()
{'areacode': '800', 'prefix': '555'}

 
 
re.sub(r'\((?P<areacode>\d{3})\) (?P<prefix>\d{3})-(?:\d{4})',
'(\g<areacode>) \g<prefix>-xxxx','(800) 555-1212')
'(800) 555-xxxx'

 
 
>>> bool(re.match(r'\((?P<areacode>\d{3})\) (?P<prefix>\d{3})-(?P<number>\d{4}) (?P=areacode)-(?P=prefix)-(?P=number) 1(?P=areacode) (?P=prefix) (?P=number)','(800) 555-1212 800-555-1212 18005551212'))
False
>>> bool(re.match(r'''(?x)
\((?P<areacode>\d{3})\)[ ](?P<prefix>\d{3})-(?P<number>\d{4})
[ ]
(?P=areacode)-(?P=prefix)-(?P=number)
[ ]
1(?P=areacode) (?P=prefix) (?P=number)
''','(800) 555-1212 800-555-1212 18005551212'))
True

 
 
>>> re.findall(r'\w+(?= van Rossum)',
'''
Guido van Rossum
Tim Peters
Alex Martertelli
Just van Rossum
Raymond Hettinger
''')
['Guido', 'Just']
>>> re.findall(r'(?m)^\s+(?!noreply|postmaster)(\w+)',
'''
sales@phptr.com
postmaster@phptr.com
eng@phptr.com
noreply@phptr.com
admin@phptr.com
''')
['sales']
>>> ['%s@aw/com' % e.group(1) for e in \
re.finditer(r'(?m)^\s+(?!noreply|postmaster)(\w+)',
'''
sales@phptr.com
postmaster@phptr.com
eng@phptr.com
noreply@phptr.com
admin@phptr.com
''')]
['sales@aw/com']
 
 
 
 用于正则表达式练习的数据生成器 

 

 
  
 
# 用于正则表达式练习的数据生成器
# !/usr/bin/env python

from random import randrange, choice
from string import ascii_lowercase as lc
from sys import maxsize
from time import ctime

tlds = ('com', 'edu', 'net', 'org', 'gov')  # 高级域名集合，随机生成电子邮箱地址是随机选出

for i in range(randrange(5, 11)):  # 取随机整数
    dtint = randrange(maxsize % 10 ** 10)
    dtstr = ctime(dtint)
    llen = randrange(4, 8)
    login = ''.join(choice(lc) for j in range(llen))
    dlen = randrange(llen, 13)
    dom = ''.join(choice(lc) for j in range(dlen))
    print('%s::%s@%s.%s::%d-%d-%d' % (dtstr, login, dom, choice(tlds), dtint, llen, dlen))
 
 
Mon Jan  6 09:40:36 2183::oegwsa@qktdkvw.org::6722098836-6-7
Wed Sep 26 23:41:01 2007::slgxibl@sntijbzx.net::1190821261-7-8
Tue Apr 27 20:13:25 2066::rcovnha@qvgmcri.org::3039596005-7-7
Tue Dec  3 14:04:16 1985::tunjdnp@tufjtftm.edu::502437856-7-8
Tue Aug 21 20:23:40 2164::qqcevl@piwbxv.edu::6142220620-6-6
Wed Nov 27 22:06:46 2137::tcbl@ajlitcishz.com::5298617206-4-10
Tue Sep 16 23:06:21 1997::hljtw@fmkwuw.gov::874422381-5-6
Tue Mar 13 10:12:27 2001::xrxzwyb@muirgwfulkgh.org::984449547-7-12
Thu Mar 16 15:51:54 2023::weig@ollmmuvk.org::1678953114-4-8
Fri Jun  4 10:49:38 2106::bzevujk@znsgkvtatq.edu::4305062978-7-10


Process finished with exit code 0

 


                

        

        

    




    

      

        

            

              
                
                  v_12138
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
正则表达式笔记

				
			

			

				

					矩阵实验室
				

				

					08-26
					
					1062
					
				

			

		

		

			
				
摘要：本文对正则表达式简要介绍，并且提供大量实例。看完此文，你会对正则表达式有一个基本的理解。
1. "."
表示任意字符（匹配除“\n”之外的任何单个字符。要匹配包括“\n”在内的任何字符，请使用像“(.|\n)”的模式。）
2. 次数
3. 选择
4. 边界
5. \ ——转义符
6. 特殊字符
7. 实例

*
匹配前面的子表达式零次或多次。


+
匹配前面的子表达式一次或多次。


?
匹配前面的子表达式零次或一次。


{n}
n是一个非负整数。匹配确定的n次。


{n,}
n是一个非负整数。

			
		

	



                

              
                



	

		

			

				
					
正则表达式 \\\\

				
			

			

				

					qq_27840621的博客
				

				

					04-26
					
					2800
					
				

			

		

		

			
				
"\\\\"字符串中，两个反斜杠被解释为一个反斜杠，再作为正则表达式， \\ 则被正则表达式引擎解释为 \，所以在正则表达式中需要使用四个反斜杠表示"\"
"*"表示零次或多次匹配前面的字符或子表达式，等价于{0，}，例如：zo* 匹配"z"和"zoo"
这里星号对 o 起作用，所以 o 可以出现零次或多次，所以可以匹配：
z //o 出现0次
zo //o 出现1次
zoo //o 出

			
		

	



                


  
              

                


	

		

			

				
					
Postman—添加断言和正则表达式（2）

				
			

			

				

					weixin_44503360的博客
				

				

					02-08
					
					895
					
				

			

		

		

			
				
前言
postman断言是JavaScript语言编写的，在postman客户端指定区域编写即可。
断言会在请求返回之后，运行，并根据断言的pass\fail情况体现在最终测试结果中。
一、断言步骤
1、打开保存的postman完成的访问百度经验的一个简单的Get请求。点击Send，查看响应信息。
这里就设置，检查响应信息里面包含：“百度新闻——全球最大的中文新闻平台”这几个字、
同时设置响应httpCode为200，断言响应成功。
2、点击Url下方的Tests，这里设置断言。
点进来后这里是空的，你如果

			
		

	





	

		

			

				
					
postman使用正则表达式提取数据实战篇！

					
最新发布

				
			

			

				

					weixin_71807218的博客
				

				

					06-17
					
					334
					
				

			

		

		

			
				
因此，刚入门的小伙伴们开始很懵懂时不要太着急，需要一个循序渐进的过程。我的建议就是一定要去找个免费开源的接口去实战，刚开始就模范参照别人的做法多练习，多去调试，然后在错误中去寻找答案，这个进步最快的方式。正则匹配表达式将需要提取的字段key:value都放入表达式中，然后将字段access_token作为键，字段值value用表达式(.*?这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你！

			
		

	



		

			
		



	

		

			

				
					
Postman的使用教程笔记

				
			

			

				

					Evil_invisible的博客
				

				

					12-15
					
					8961
					
				

			

		

		

			
				
Postman的使用教程笔记

			
		

	





	

		

			

				
					
Postman接口关联使用正则表达式提取

				
			

			

				

					沫沫1890S的博客
				

				

					11-29
					
					1273
					
				

			

		

		

			
				
Postman接口关联：当请求之间有依赖关系, 比如一个请求的入参是另一个请求返回的数据, 这时候需要用到关联处理（全局变量的设置）

			
		

	





	

		

			

				
					
Python笔记—正则表达式

				
			

			

				

					12-22
				

			

		

		

			
				
Python笔记—正则表达式1. \d ：匹配一个数字字符。等价于 [0-9]。2. \D：匹配一个非数字字符。等价于 [^0-9]。3. \[ ]4. \-5. { }：6. \* 、+ 和 ？7. ^ 和 $8. ()9. re.I 和 re.S10. re.sub()：字符替换函数11. ...

			
		

	





	

		

			

				
					
初学者python笔记（re模块、正则表达式完全解析）

				
			

			

				

					01-21
				

			

		

		

			
				
今天总结一下正则表达式，它用来解决模糊匹配的问题，几乎在所有编程语言中都可以用，尤其在python爬虫中，它是一门必修知识； 所谓模糊匹配，就是在匹配字符串中，有一部分是确定的，另一部分是不确定的值但有范围...

			
		

	





	

		

			

				
					
postman 非常好用的同域名api测试工具

				
			

			

				

					07-21
				

			

		

		

			
				
来源于下载的google浏览器的插件
测试api 同域名
支持post get等很强大的功能
 我添加了 参数选中功能

			
		

	





	

		

			

				
					
JavaScript 学习笔记（十四） 正则表达式

				
			

			

				

					10-29
				

			

		

		

			
				
### 正则表达式  正则表达式是处理字符串的强大工具，它定义了一种字符串匹配的模式，可以用来检查、搜索、替换那些符合某个模式（规则）的文本。在JavaScript中，正则表达式的使用非常广泛，主要通过RegExp类来实现...

			
		

	





	

		

			

				
					
python正则表达式详解笔记,python正则表达式教学.doc

				
			

			

				

					10-01
				

			

		

		

			
				
### Python正则表达式详解  #### 一、正则表达式概述  正则表达式（Regular Expression）是一种在计算机科学领域广泛使用的模式匹配工具。它主要用于处理文本数据，包括搜索、替换以及提取文本中的特定模式。许多...

			
		

	





	

		

			

				
					
关于postman使用正则表达式抓取返回值遇到的问题+解决方法

					
热门推荐

				
			

			

				

					ovo______的博客
				

				

					12-23
					
					1万+
					
				

			

		

		

			
				
1返回值中存在多个括号 需要取括号内的某个值
解决方法：
使用postman正则表达式获取
源代码：（直接复制粘贴更改一下即可）
//获取taskDetailJson(任务详情)的值1
var jsonData=JSON.parse(responseBody);
pm.globals.set(“taskDetailJson”, jsonData.data.taskList[0].taskDetailJson.match(new RegExp(‘word\":\"(.+?)\"’))[1]);
//获取tas

			
		

	





	

		

			

				
					
Python正则表达式（二）

				
			

			

				

					ds19991999的博客
				

				

					07-30
					
					3677
					
				

			

		

		

			
				
Python正则表达式

具体见个人Python图书馆：https://ds-ebooks.github.io 
官方文档：re

Contents



Python正则表达式
Contents
re模块
re常用函数
使用 match()方法匹配字符串
使用search()在一个字符串中查找模式（搜索与匹配的对比）
匹配多个字符串（|）
匹配任何单个字符
创建字符集([ ])
重复、特殊字符以...

			
		

	





	

		

			

				
					
python学习笔记正则表达式re模块

				
			

			

				

					mega16的专栏
				

				

					12-30
					
					490
					
				

			

		

		

			
				
1.使用match()和search()匹配字符串，使用group()查看结果match() :从字符串开始的位置匹配，成功返回匹配的对象，失败返回None 
search(): 扫描整个字符串来进行匹配，成功返回匹配的对象，失败返回None例1：比较match() 和 search()的区别
import rem = re.match('foo', 'seafood')
if m is not N

			
		

	





	

		

			

				
					
正则表达式及常用编辑查找命令

				
			

			

				

					weixin_33806509的博客
				

				

					03-21
					
					285
					
				

			

		

		

			
				
一、正则表达式正则表达式（或称Regular Expression，简称RE）就是由普通字符（例如字符 a 到 z）以及特殊字符（称为元字符）组成的文字模式。该模式描述在查找文字主体时待匹配的一个或多个字符串。正则表达式作为一个模板，将某个字符模式与所搜索的字符串进行匹配。简单的说，正则表示式就是处理字符串的方法，它是以行为单位来进行字符串的处理行为， 正则表示式通过一些特殊...

			
		

	





	

		

			

				
					
Python 正则表达式  示例

				
			

			

				

					yisuoyanyv的博客
				

				

					08-18
					
					1633
					
				

			

		

		

			
				
Python正则表达式代码示例使用match()方法匹配字符串，从字符串起始部分对模式进行匹配。成功返回一个匹配对象，否则返回None，匹配对象的group()方法能够用户显示那个成功的匹配import re
m=re.match('foo','foo')#模式匹配字符串
if m is not None:#如果匹配成功，就输出匹配内容
    m.group()m#确认返回的匹配对象<_sre.S

			
		

	





	

		

			

				
					
"Python爬虫学习笔记：正则表达式与re库基本使用

				
			

			

				

					
				

			

		

		

			
				
Python爬虫学习笔记.pdf是一本介绍Python爬虫学习的重要文档。...因此，推荐对于爬虫学习感兴趣的朋友们，认真阅读并学习《Python爬虫学习笔记.pdf》中关于正则表达式的相关内容，相信会对你的学习和实践有所帮助。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值