15_python笔记-正则表达式

最新推荐文章于 2021-10-15 22:10:00 发布
最新推荐文章于 2021-10-15 22:10:00 发布
阅读量1.2k 收藏 3
点赞数 1
分类专栏： Python笔记 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cPen_web/article/details/109594530
版权

文章目录


博客cpen_web

练习1

1、实现九九乘法表
2、实现1-100之和
3、如何跨模块共享变量
4、python中生成随机整数（1-10），随机小数(1-10),0-1随机小数的方法
5、python中哪些是可变数据类型，哪些是不可变数据类型，为什么
6、统计字符串中每个字符出现的次数
7、python实现，给定一个字符串，找到字符串中第一个重复的字符
8、重复接受一个用户输入的字符，如果是正整数，就输出结果，否则就一直输入
9、用python实现冒泡排序

1、实现九九乘法表

def lx01():  # 九九乘法表
    for i in range(1, 10):							# 注：range(1, 10) --> 1...9
        for j in range(1, i + 1):						# 注：range(1, i + 1) --> 1...i
            print(f"{j}*{i}={j * i}", end=" ")			# 注：end指定结尾字符串
        print()									# 注：print默认输出换行符

2、实现1-100之和

方法1

def lx02():  # 累加
    nub = 0
    for i in range(100):
        i += 1
        nub += i
    print(nub)

方法2

print(sum(list(range(1,101))))		# 注：range(1,101)直接转换成列表使用sum进行求和
				# 注：range是可迭代对象

3、如何跨模块共享变量

使用导入这个文件，调用文件里的变量，可以实现跨模块共享

4、python中生成随机整数（1-10），随机小数(1-10),0-1随机小数的方法

def lx04():  # 随机数
import random
    print(random.randint(1, 10))				# 注：生成随机整数的范围
    print(random.uniform(1, 10))				# 注：生成随机小数的范围
    print(random.random())					# 注：生成0-1随机小数的范围

5、python中哪些是可变数据类型，哪些是不可变数据类型，为什么

# 当该数据类型的对应变量的值发生了改变，那么它对应的内存地址也会发生改变，就称不可变数据类型
# 包括：int（整型）、string（字符串）、tuple（元组）
# 当该数据类型的对应变量的值发生了改变，那么它对应的内存地址不发生改变，就称可变数据类型
# 包括：set（集合）、list（列表）、dict（字典）

6、统计字符串中每个字符出现的次数

def lx06():  # 统计次数
    str_1 = input("请输入字符串： ")
    for i in set(str_1):							# 注：对str进行set集合去重
        print(f"字符{i}出现了{str_1.count(i)}次")

7、python实现，给定一个字符串，找到字符串中第一个重复的字符

def lx07():  # 找第一个重复字符
    str_1 = input("请输入字符串： ")
    for i in str_1:
        if str_1.count(i) > 1:
            print(f"第一个重复的字符为{i}")
            return								# 注：大于1时直接return退出函数

8、重复接受一个用户输入的字符，如果是正整数，就输出结果，否则就一直输入

def lx08():
    while True:
        str_1 = input("请输入： ")
        if str_1.isdigit():							# 注：str isdigit 判断是不是只有数字
            print(str_1)
        else:
            print("你输入的不是正整数，退出程序")
            return

9、用python实现冒泡排序

def lx09():
    list_1 = [46,45,13,78,65,99,45]
    n = len(list_1)

    # 遍历所有数组元素
    for i in range(n):
        for j in range(0, n - i - 1):
            if list_1[j] > list_1[j + 1]:
                list_1[j], list_1[j + 1] = list_1[j + 1], list_1[j]
    print(f"排序后的数组为{list_1}")

def bubbleSort(arr):
    n = len(arr)
    # 遍历所有数组元素
    for i in range(n):
        # Last i elements are already in place
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

arr = [64, 34, 25, 12, 22, 11, 90]
bubbleSort(arr)
print("排序后的数组:")
for i in range(len(arr)):
    print("%d" % arr[i])

示例：冒泡排序的改进 引入标志位 判定某件事情是否发生

list1 = [1,4,6,2,5,3,9,7,8]
length = len(list1) - 1
i = j = 0
while i < length:
    flag = 1		# 注：标志位
    print(f"第{i+1}次，list:{list1}")
    j = 0
    while j < length - i:
        if list1[j] > list1[j + 1]:
            list1[j],list1[j + 1] = list1[j + 1],list1[j]
            flag = 0        # 注：有交换的情况下 flag = 0
        j += 1
    if flag:                # 注：if flag  flag=1的时候 break退出
        break
    i += 1
print(list1)

第1次，list:[1, 4, 6, 2, 5, 3, 9, 7, 8] # 注：改进后 只需要排序4次
第2次，list:[1, 4, 2, 5, 3, 6, 7, 8, 9]
第3次，list:[1, 2, 4, 3, 5, 6, 7, 8, 9]
第4次，list:[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

Python里交换数值

>>> a = 1
>>> b = 2
>>> a
1
>>> b
2
>>> a, b = b, a
>>> a
2
>>> b
1

练习2

1、循环接收键盘输入的字符，判定是否属于正整数、负整数、浮点数 ，并给出相应提醒 按exit退出

while True:
    import re
    num = input("请输入：")
    if re.findall(r"^\+?[1-9]\d*$",num):
        print("正整数")
    elif re.findall(r"^\-[1-9]\d*$",num):
        print("负整数")
    elif re.findall(r"^[\+|\-]?\d+\.\d+$",num):
        print("浮点数")
    elif num == "exit":
        break
    else:
        print("重新输入")

2、验证密码是否合法，密码要求8-10位，以（字母或者下划线开头），给出相应提示

import re
passwd = input("请输入：")
if re.findall("^[A-Za-z_].{7,9}$",passwd):
    print("密码合法")
else:
    print("密码不合法")

3、提取电话号码

wen tel: 17375722991
wen tel: 173-7572-2992
wen tel: 173 7572 2993
wen tel: (+86) 17375722994

format1 = input("请提取出你输入的格式：")
import re
ret = re.search("(\(\+86\))?1\d{2}([ \-]?\d{4}){2}",format1)
print("打印:",ret)

#注：分组向后引用 ret = re.search(r"1\d{2}([ \-]?)\d{4}\1\d{4}",format1)   # 注：进行分组向后引用

请提取出你输入的格式：12345678901
打印: <re.Match object; span=(0, 11), match=‘12345678901’>
请提取出你输入的格式：123-4567-8901
打印: <re.Match object; span=(0, 13), match=‘123-4567-8901’>
请提取出你输入的格式：123 4567 8901
打印: <re.Match object; span=(0, 13), match=‘123 4567 8901’>
请提取出你输入的格式：(+86)12345678901
打印: <re.Match object; span=(0, 16), match=’(+86)12345678901’>

知识点3 正则分组

正则分组-简单分组

当使用分组时，除了可以获得整个匹配，还能够获得选择每一个单独组，使用 () 进行分组

简单分组

分组不匹配（?:规则）
· 表示将()仅用于组合字符串，不识别为分组

正则分组-命名分组

命名分组：（？P规则）

正则分组-引用分组
引用分组：
·使用()分用，用\0, \1, \2引用 （\0表示匹配的整个串）

示例1：正则分组

#正则分组
import re
ret = re.search(r'(\d{3})-(\d{3})-(\d{3})',"123-321-234abc") # 注：数字匹配3次 作为1个分组
print(ret.group())      # group正则表达式能获得的所有对象
#结果为 123-321-234
print(ret.group(0))     # 0代表所有匹配的字符，不接参数 默认为0
#结果为 123-321-234
print(ret.group(1))     # 1代表第1个组 获取第1个分组
#结果为 123
print(ret.group(2))     # 2代表第2个组
#结果为 321
print(ret.group(3))     # 3代表第3个组
#结果为 234
#print(ret.group(4))
#注：报错 IndexError: no such group

#注：返回每一个单个分组的元组
print(ret.groups())     # 获取每一个分组里的值，放到1个元组里，返回1个元组
#结果为 ('123', '321', '234')

#捕获分组和非捕获分组
#分组向后引用

示例2：捕获分组

str = "a1 a2 a1 a2"

#正常的是捕获分组
#捕获分组 （分组并捕获，分组之后匹配到的数据，会放到内存中，并且给定一个从1开始的索引）
print(re.search(r"([a-z]\d ){3}([a-z]\d)", str))
#结果为 <re.Match object; span=(0, 11), match='a1 a2 a1 a2'>
print(re.search(r"([a-z]\d)\s+([a-z]\d)\s+\1\s+\2", str))       #\1跟前面分组1一摸一样 \2跟第2个分组一模一样
#结果为 <re.Match object; span=(0, 11), match='a1 a2 a1 a2'>
#分组向后引用 \1 返回的是a1[第1个分组] \2 返回的是a2[第2个分组]

#findall 有捕获分组的话，只会输出捕获分组里的内容
print(re.findall(r"([a-z]\d)\s+([a-z]\d)\s+\1\s+\2", str))
#结果为 [('a1', 'a2')]
#findall只会打印捕获分组里面的东西（a1 a2）

示例3：非捕获分组(?😃

#非捕获分组(?:)  只是分组，不捕获，不会在内存中缓存分组匹配的值，不会分配从1开始的下标索引
str2 = "a1 a2 a2 a1"
ret = re.search(r"(?:\w\d)\s+(\w\d)\s+\1", str2)    # 注：非捕获分组仅仅只是给它分组 不捕获
print(ret)
#结果为<re.Match object; span=(0, 8), match='a1 a2 a2'>
#(?:\w\d)非捕获分组 不会占用下标索引

#findall
#有捕获分组的话，只会输出捕获分组里的内容
#没有捕获分组的话，输出全部内容
ret = re.findall(r"(?:\w\d)\s+(\w\d)\s+\1", str2)   # 注：有捕获分组时 只会输出捕获分组里的内容
print(ret)
#结果为 ['a2']
ret = re.findall(r"(?:\w\d)\s+(?:\w\d)\s+", str2)   # 注：没有捕获分组的话，输出全部内容
print(ret)
#结果为 ['a1 a2 ']

示例4：命名分组

#命名分组       # 注：命名分组合也是捕获分组 取了个名字
ret = re.search(r'(?P<name>\d{3})-\d{3}-(?P<last>\d{3})', "123-321-234abc")
print(ret.group(1))
#结果为 123
print(ret.group("name"))
#结果为 123 命令分组
print(ret.group(2))
print(ret.group("last"))
#结果都为 234 命名分组
print(ret.groupdict())  # 注：匹配到的值变为字典输出
#结果为 {'name': '123', 'last': '234'}     #name就是key,取到的值是value
#获取所有匹配的字符串-字典形式
print(ret.groups())     # 注：获取所有匹配的字符串
#结果为 ('123', '234')

示例5：引用分组

#引用分组
msg = """
<div>hello</div>
<h1>hello</h1>
"""
ret = re.findall(r'(<(\w+)>hello</\2>)', msg)   # 注：外面的分组是第1个 ； 里面的分组是第2个
print(ret)                      # 注：所以后面是 \2
#结果为 [('<div>hello</div>', 'div'), ('<h1>hello</h1>', 'h1')]
#注：一个分组 findall匹配的是一个普通元素，一个以上的分组 findall匹配结果是 元组

ret = re.findall(r'<(\w+)>hello</\1>', msg)	# 注：这种与期望不符
print(ret)
#结果为 ['div', 'h1']

练习4

1、匹配里面的每一个单词，引号部分作为一个单词输出

msg = ‘san chuang tong le, huan ying ni “hello world”, learn python’

示例

import re
msg = 'san chuang tong le, huan ying ni "hello world", learn python'
ret = re.findall(r'\w+|"[\w ]+"', msg)     # 注：\w+ 匹配1次到多次 "[\w ]+" 匹配1次到多次
print(ret)					# 注：\w+ 匹配每一个单词
#结果为 ['san', 'chuang', 'tong', 'le', 'huan', 'ying', 'ni', '"hello world"', 'learn', 'python']
#注：匹配到“就会判断是否满足第2个条件
#注："[\w ]+"  引号里面匹配单词字符 或 空格 匹配1次到多次  "hello world"
#或者
ret = re.findall(r'"[\w ]+"', msg)
ret = re.findall(r'".*"', msg)
print(ret)
#结果为 ['"hello world"']

import re				# 注：没解决问题
msg = 'san chuang tong le, huan ying ni "hello world", learn python'
ret = re.findall(r'\w+|(?<=")(?:[\w ]+)(?=")', msg)     # 注：零宽断言
print(ret)					# 注：没解决问题
#结果为 ['san', 'chuang', 'tong', 'le', 'huan', 'ying', 'ni', 'hello', 'world', 'learn', 'python']

ret = re.findall(r'(?<=\")(?:[\w ]+)(?=")|\w+', msg)
print(ret)					# 注：解决问题了  因为断言先行
#结果为 ['san', 'chuang', 'tong', 'le', 'huan', 'ying', 'ni', 'hello world', 'learn', 'python']

2、msg = ‘123@qq.comaaa@126.combbb@163.comcc@abc.com’

#–> 123@qq.com aaa#126.com bbb@163.com

示例

import re
msg2 = 'yyy@xx.com123@qq.comaaa@126.combbb@163.comcc@abc.com'
# --> 123@qq.com  aaa#126.com  bbb@163.com
ret = re.findall("\w+@(qq|163|126).com", msg2)        # 注：捕获分组
print(ret)      # 注：只会捕获到分组的
#结果为 ['qq', '126', '163']
ret = re.findall("\w+@(?:qq|163|126).com", msg2)      # 注：非捕获分组
print(ret)
#结果为 ['com123@qq.com', 'aaa@126.com', 'bbb@163.com']
ret = re.findall("(?:\.com)?(\w+@(?:qq|163|126)\.com)", msg2)
print(ret)  # 注：从左往右依次匹配 com匹配0-1次 满足 ；匹配到com ;后面匹配0次 满足条件
#结果为 ['123@qq.com', 'aaa@126.com', 'bbb@163.com']
#先在最开始找匹配0次或1次；模板往例子里套 @xx没有被匹配到
#findall有捕获分组的情况下 只会输出捕获分组 不会输出非捕获分组 所以没有输出最前面的.com
#注：非捕获分组，不会给它索引下标

ret = re.findall("(\.com)?(\w+@(?:qq|163|126)\.com)", msg2) # 注：捕获分组 作为元组输出
print(ret)          # 注：捕获分组 作为元组输出
#结果为 [('.com', '123@qq.com'), ('', 'aaa@126.com'), ('', 'bbb@163.com')]

3、输出成对存在的中间的内容（test2、test3）

#test1

test2
test3
#–> 输出test2 test3

示例

import re
msg3 = '<html>test1<div>test2</div><a>test3</a></html>'
# reg3 = re.findall(r"(?:<\w+>)\w+(?:</\w+>)",msg3)
ret = re.findall(r'<(\w+)>(\w+)</\1>', msg3)    # 注：\1分组向后引用，表示第1个分组里面的内容
print(ret)      # 注：匹配一组对应的标签
#结果为 [('div', 'test2'), ('a', 'test3')]
#捕获分组，捕获到的项会先放在内存中，并且给它一个索引从1开始

知识点5 正则标记-第三个参数

正则标记-第三个参数
第三个参数
正则标记-第三个参数

示例

#正则标记
import re
msg = """
Python
python
"""
ret = re.findall(r"^python$", 'PYTHOn')
print(ret)  # 注：匹配不上
#结果为 []

#对大小写不敏感的标志位
ret = re.findall(r"^python$", 'PYTHOn',re.I)
print(ret)
#结果为 ['PYTHOn']

ret = re.findall(r"^python$", msg,re.I)
print(ret)  # 注：把msg作为字符串去匹配 ；做一个整体匹配 ； p开头n结尾
#结果为 []
#多行匹配和大小写不明感
ret = re.findall(r"^python$", msg,re.I|re.M)    # 注：re.M 多行匹配
print(ret)  # 注：re.M 进入 多行匹配 模式 每一行都匹配
#结果为 ['Python', 'python']       # 注：|或运算符 支持多条匹配

#re.S                           # 注：使.匹配包括换行在内的所有字符
ret = re.findall(r".+",msg)     # 注：.任意字符匹配 \n换行符 不匹配
print(ret)
#结果为 ['Python', 'python']
#re.S
ret = re.findall(r".+",msg, re.S)   # 注：使.匹配包括换行在内的所有字符
print(ret)				# 注：re.S从头到为全部匹配
#结果为 ['\nPython\npython\n']

知识点6 基本正则匹配-内联标记

基本正则匹配-内联标记
内联标记
基本正则匹配-内联标记
内联标记：(?imx)re
内联标记：(?imx: re)

#注：写在正则表达式前面
(?i:不区分大小写)

i 不区分大小写 # 注：不清楚
m 多行匹配 # 注：不清楚

示例

#内联标记: (?imx)re
import re
ret = re.findall('(?i)^python$', 'Python')
print(ret)
#结果为 ['Python']
ret = re.findall('(?i)^python$', 'Python\npython')
print(ret)
#结果为 []
ret = re.findall('(?im)^python$', 'Python\npython')
print(ret)
#结果为 ['Python', 'python']

#内联标记：(?imx:re)
import re
msg = "Hello Python"
ret = re.findall('(?i:hello) python', "Hello Python")
print(ret)
#结果为 []
ret = re.findall('(?i:hello) Python', "Hello Python")
print(ret)
#结果为 ['Hello Python']

练习7 提取url域名

#提取url域名
#https://music.163.com/#/discover/toplist
#http://www.baidu.com?a=1
#http://news.xinlang.cn
#http://news.xin.lang.cn
#htp://www.baidu.com    # 不属于url

示例

import re
msg = """
https://music.163.com/#/discover/toplist
http://www.baidu.com?a=1
http://news.xinlang.cn
http://news.xin.lang.cn
htp://www.baidu.com
"""
ret = re.findall('(?:https?://)((?:\w+\.)+\w+)', msg,re.M)
print(ret)
#结果为 ['music.163.com', 'www.baidu.com', 'news.xinlang.cn', 'news.xin.lang.cn']
#注：(?:https?://) ?对s匹配0次或1次
#注：(?:\w+\.)+  music.163. 匹配1次以上
#注：\w+         com        匹配1次以上
#注：((?:\w+\.)+\w+) 外面这一层是捕获分组

知识点8 正则表达式断言

正则表达式断言
正则表达式的断言分为：先行断言(lookahead)和后行断言(lookbehind)
正则表达式的先行断言和后行断言一共有4种形式：

·(?=pattern) 零宽正向先行断言(zero-width positive lookahead assertion)
·(?!pattern) 零宽负向先行断言(zero-width negative lookahead assertion)
·(?<=pattern) 零宽正向后行断言(zero-width positive lookbehind assertion)
·(?<!pattern) 零宽负向后行断言(zero-width negative lookbehind assertion)

零宽
· ^python

正向、负向
· 正向：匹配(?=pattern)/(?<=pattern)
· 负向：不匹配(?!pattern)/(?<!pattern)

先行、后行
· 先行：向后匹配(?=pattern)/(?!pattern)
· 后行：向前匹配(?<=pattern)/(?<!pattern)

零宽正向先行断言：(?=pattern)
· 代表字符串中的一个位置，紧接该位置之后的字符序列能够匹配pattern。
· 匹配字符串re，后面能接gular(但不匹配宽度)

零宽负向先行断言：(?!pattern)
· 代表字符串中的一个位置，紧接该位置之后的字符序列不能匹配pattern。
· 匹配字符串re，但是后面不能接gular

零宽正向后行断言：(?<=pattern)
· 代表字符串中的一个位置，紧接该位置之前的字符序列能够匹配pattern。
· 匹配gular，但前面必须是re

零宽负向后行断言 ：(?<!pattern)
· 代表字符串中的一个位置，紧接该位置之前的字符序列不能匹配pattern。
· 匹配gular，但前面不能是re

示例

#零宽断言
#匹配位置的参数不会输出
s = "a regular rbgular expression"
#零宽正向先行断言
print(re.findall(r"re(?=gular)",s))     # 注：匹配右边等于gular的re
#结果为 ['re']
#零宽断言 只匹配re gular(位置) 不占宽度gular
s = "a regularression"
# print(re.findall(r"re(?=gular)re(?=ssion)",s))    # 匹配不了2个，所以不要这么用
#结果为[]

#零宽负向先行断言
s = "a regular rbgular expression"
print(re.findall(r"re(?!gular)",s))     # 注：匹配re；后面不等于gular的re
#结果为 ['re']

s = "a regular rbgular expression"
print(re.findall(r"\w+(?=gular)",s))
#结果为 ['re', 'rb']
print(re.findall(r"\w+(?!gular)",s))    # 注：不是很理解
#结果为 ['a', 'regular', 'rbgular', 'expression']

#零宽正向后行断言
s = "a regular rbgular expression"
print(re.findall(r"(?<=re)gular",s))    # 注：匹配左边是re的gular
#结果为 ['gular']

#零宽负向后行断言
s = "a regular rbgular expression"
print(re.findall(r"(?<!re)gular",s))    # 注：匹配左边不是re的gular
#结果为 ['gular']

练习9 使用零宽断言提取ip地址

print(re.findall(r"(?<=inet ).*(?=/)"),ip)
#注：前面用零宽正向先行断言，后面用零宽负向先行断言
#注：前面加<号，后面不加<号
mycpen
关注
专栏目录
python正则表达式去除非中文字符
JanLEE
11-02 867
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Date : 2021/10/28 # @Author : 80006339 # @description : # @File : shop正则表达式处理店铺名.py. # @Software: PyCharm # shop正则表达式处理店铺名 import re import pandas as pd import csv from string import digits csv.field_size_l
python笔记-正则表达式
qq_42687283的博客
10-12 180
通配符的使用 * : 0个到无穷多个任意字符 ? :一个必定存在的任意字符 . :当前路径 .. :上一级路径 [0-9]:0到9所有数字 [a-z]:a到z所有小写字母 [A-Z]:A到Z所有大写字母 [a-zA-Z]：所有字母 官方参考代码: &gt;&gt;&gt; import glob &gt;&gt;&gt; glob.glob('./[0-9].*') ['./1.gif', '....
python 正则 去除汉字以外字符_Python正则表达式——匹配单个字符
weixin_39954487的博客
12-19 1152
这一节我们介绍一下关于单个字符的匹配。import re # . 匹配任意单个字符 ma = re.match(r'a', 'a') print(ma.group()) # 输出：a ma = re.match(r'.', 'b') print(ma.group()) # 输出：b ma = re.match(r'.', '9') print(ma.group()) # 输出：9 #...
删除汉字、字母、数字以外的其它字符
小彬~
12-23 423
String str = "!!@@##你好110@#$%"; str.replaceAll("[[^\u4E00-\u9FA5]&amp;&amp;[^a-zA-Z0-9]]", "");  
python正则表达式去掉特殊字符_如何在python中使用正则表达式从多行字符串中删除特定字符...
weixin_39996134的博客
12-03 1404
我有一个如下所示的多行字符串：st = '''emp:firstinfo\n:secondinfo\nthirdinfo'''print(st)我正在尝试做的是从我的字符串中跳过第二个'：'，并获得如下所示的输出：'''emp:firstinfo\nsecondinfo\nthirdinfo'''简单说，如果它以'：'开头，我只想忽略它。这是我所做的：mat_obj = re.match(r'(....
python用正则表达式替换掉汉字、标点等指定字符以外的特殊字符
热门推荐
Amy的专栏
10-31 2万+
用习惯java的正则表达式，今天在python里也想用相同的正则处理一些文本，结果发现python和java的差别还挺大的，网上一顿搜索之后发现内容又是千篇一律，也满足不了我的需求，于是自己摸索后，总结python区别于java的几点注意事项： 目标：替换掉 汉字、英文、数字、常用中文标点符号 以外的其他字符 java实现： python实现： 注意： （1）python
python学习笔记(十一) - 正则表达式
技术人生
02-06 1397
一.基础知识： \d 匹配一个数字 \w 匹配一个字母或数字 . 匹配任意字符 * 表示任意个字符 + 表示至少一个字符 ? 表示0个或1个字符 {n} 表示n个字符，{n, m} 表示n - m个字符 \s 表示匹配一个空格(包括Tab等空白符)，\s+表示至少一个空格 [0-9a-zA-Z\_] 可以匹配一个数字、字母或者下划线 [0-9a-zA-Z\_]+ 可以匹配至少由
Python—-正则表达式
12-22
Python学习之路，点击有全套Python笔记 常用特殊符号和字符: 匹配一个范围[]：[A-Z0-9] 匹配前面出现的正则表达式任意多次，包含0次 *：[abc]* 匹配前面出现的正则表达式0次或1次 ？：a? 匹配前面出现的正则表达式一...
05-python-sys模块简介-与操作系统进行交互-CSV文件和CSV模块-正则表达式
02-09
这些笔记中，05.04-python-正则表达式和 re 模块.ipynb可能包含了关于如何使用正则表达式和re模块的实际示例和练习；05.02-python-与操作系统进行交互.ipynb可能讲解了如何利用sys模块与操作系统进行互动；05.03-...
Python字符串与正则表达式学习笔记
12-20
在Python编程语言中，字符串和正则表达式是两个非常重要的概念，广泛应用于数据处理、文本分析和信息提取。下面是对这两个主题的详细说明。 ### 1. 数值与布尔型 在Python中，数值类型主要包括整型（int）和浮点型...
python正则表达式详解笔记,python正则表达式教学.doc
10-01
### Python正则表达式详解 #### 一、正则表达式概述 正则表达式（Regular Expression）是一种在计算机科学领域广泛使用的模式匹配工具。它主要用于处理文本数据，包括搜索、替换以及提取文本中的特定模式。许多...
Android、Python过滤非中文特殊字符
qq_44023485的博客
10-15 474
Android: tring pattern = "[^\\w\\u4e00-\\u9fff]"; Pattern r = Pattern.compile(pattern); Matcher m = r.matcher("江苏 » 无锡市:婚礼司仪roger"); String newStr = m.replaceAll(""); Python: import regex as re new_str = re.sub('[^\w\u4e00-\u9fff]+', '','江苏 » 无锡市:婚礼司仪rog
python删除文本中除汉字外所有的字符_【数会小课堂】Python知识第二弹
weixin_32597695的博客
01-24 1482
通过上次的学习我们已经对python有了一定程度的了解，今天，我们来进一步学习有关Python中的变量与简单数据类型的内容。01Python中的变量变量一般是用于储存信息的字符。变量在大多数编程语言中起着非常重要的作用，Python也不例外。Python中使用等号给变量赋值，例如：变量可以被重新赋值，在python中变量没有特定的类型，除了数字，也可以将字符串分配给变量。使用“==”可以...
正则表达式——去除文本中的非汉字（VB2005）
万仓一黍
11-17 3767
本人由于工作关系，需要一段代码，将给定的字符串中的非汉字去除，只保留汉字部分。这个一般用正则表达式比较简单，网上有一些匹配汉字的正则表达式，拿来经过改造就能实现我前面的要求。Public Function OnlyChinese(ByVal mText As String) As String
 Return System.Text.RegularExpressions.Re
正则匹配内容是否含有除汉字数字英文以外的字符
lnniyunlong99的专栏
10-16 5675
/**       * 检查输入的数据中是否有除了汉字字母和数字以外的字符     * @param qString 要检查的数据      * @return boolean 如果包含正则表达式 regx 中定义的特殊字符，返回true；      * 否则返回false       */       public static boolean hasCrossScriptRis
正则表达式限制非中文字符输入
dengzy
09-24 1万+
中文字符的unicode编码 \u4e00-\u9fa5 &lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;web&lt;/title&gt; &lt;link rel="styl
正则表达式大全
arvinzd的博客
01-06 445
一、校验数字的表达式    1 数字：^[0-9]*$  2 n位的数字：^\d{n}$  3 至少n位的数字：^\d{n,}$  4 m-n位的数字：^\d{m,n}$  5 零和非零开头的数字：^(0|[1-9][0-9]*)$  6 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$  7 带1-2位小数的正数或负数：^(\-)?\d+(\.\...
8_python笔记-元组-字典-集合
cPen_web的博客
10-27 1736
8_python笔记-元组-字典-集合 博客 知识点1 容器类型 - 列表 回顾 ############################################################################### 知识点2 练习 有一个列表[‘python’, ‘Java’, ‘C’ ] ·向列表中追加一个元素：‘我是追加’ ·删除第一个元素和最后一个元素 ·判断”Cali”是否在列表里 ·知道列表元素的总数 ·插入一个子列表[‘liu’，‘cali’，123,456]到父列表
Python re模块详解：正则表达式语法解析
"这篇学习笔记主要探讨Python中的正则表达式语法，包括使用re模块进行字符串匹配、替换和提取操作，以及各种特殊字符的功能解释。" 在Python编程中，正则表达式是一种强大的文本处理工具，它允许我们通过模式匹配来...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

mycpen

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值