Python系列五之正则表达式

正则表达式,Regular Expression,可用于在一个目标字符串里对于指定模式的字符进行查找、替换、分割等操作。

比如,判断某个字符串里是否都是数字,或者是否包含指定字符串,又或者更直接的例子是判断电话号码或者邮箱是否合法等。

这一篇笔记里,我们将先介绍一个正则表达式的函数,并以此来引入正则表达式的各种模式,并辅以各个例子进行介绍。

u1s1,正则表达式,我学了三四遍,学一遍忘一遍,忘一遍学一遍,只要隔一阵子不用就会忘,所以这一篇笔记力求将正则表达式的所有模式和用法都记录下来,用作之后的查找笔记。

以下笔记使用 Python 版本是 3.8。

以下是本篇笔记目录:

  1. re.findall
  2. 表达式语法
    1. 匹配字符串类型
      1. \b-匹配空字符串,但只在单词开始或结尾
      2. \B-匹配空字符串,不能在开头或结尾
      3. \d-匹配十进制数字
      4. \D-匹配非十进制字符
      5. \s-匹配空白字符
      6. \S-匹配非空白字符
      7. \w-匹配字符
      8. \W-匹配非单词字符
    2. 匹配字符串出现位置
      1. \A-只匹配字符串开始
      2. \Z-只匹配字符串结尾
      3. ^-匹配字符串开头
      4. $-匹配字符串结尾
    3. 匹配字符串数量
      1. *-匹配重复 0 到 n 次
      2. +-匹配重复 1 到 n 次
      3. ?-匹配重复 0 到 1 次
      4. {}-指定匹配重复次数
        a. {m}-只匹配重复 m 次
        b. {m,n}-匹配重复 m 到 n 次
    4. 匹配字符串集合
      1. 字符可以单独列出
      2. 可以表示字符范围
      3. 特殊字符在集合里只会匹配其原始字符含义
      4. 字符类 \s 或 \w 可以在集合里使用
      5. 取反操作可以使用 ^
    5. 其他匹配类型
      1. |-表达式的或操作
      2. ()-匹配括号内的任意正则表达式
  3. 常用正则方法
    1. re.search
    2. re.match
    3. re.split
    4. re.findall
    5. re.finditer
    6. re.sub
    7. re.subn
    8. re.compile
    9. 其他参数
      1. re.I
      2. re.M
  4. re.Match 匹配对象
    1. Match.group()
    2. Match.__getitem__(g)
    3. Match.groups()
    4. Match.re
    5. Match.string
    6. Match.start() 和 Match.end()
    7. Match.span()

1、re.findall

使用正则表达式,首先要引入模块:

import re

这里从 re.findall 开始介绍,findall 方法表示的是找到目标字符串里符合指定模式的全部数据。

比如我们有一个字符串 abcdefg,想要从其中找到 de,就可以如下操作:

str_1 = "abcdefg"
target_str = "de"
print(re.findall(target_str, str_1))

返回的就是一个列表,列表元素是我们的目标字符串 de

['de']

我们的 target_str 就是一个匹配模式,这里是一个纯字符串,我们可以将其替换成其他的模式字符串。

接下来我们将分类介绍正则表达式语法。

2、表达式语法

正则表达式有很多种,比如表示匹配数量的 +*?,还有表示匹配字符串内容的 \s\w 等。

下面将从这些类别分别开始介绍:匹配字符串类型、匹配字符串出现位置、匹配字符串数量、匹配字符串集合等

1. 匹配字符串类型

1) \b-匹配空字符串,但只在单词开始或结尾

\b 可以匹配空字符串,但是只在字符串开始或者结尾的位置,这里的空字符串涵盖了标签符号,比如 , . ,。? 等,也包括换行制表符 \n \t 等,也包含 '',可以理解为字符串的边界部分。

所以 \b 的作用其实就可用于匹配特定字符串的前缀或者后缀,这里的前缀和后缀并不仅仅是指整个字符串的前缀和后缀,也包括字符串内部被分割的前缀和后缀。

比如对于下面这个字符串:

i have a apple

我们想找到是否有 ha 开头的单词,可以如此操作:

str_1 = "i have a apple"
target_pattern = r"\bha"
print(re.findall(target_pattern, str_1))

字符串如果是以下几种情况,也可以匹配上:

str_1 = "i ,have a apple"
str_1 = "i \thave a apple"
str_1 = "i ha"

我们还可以使用 \b 来匹配特定的单词,在英文中,单词的出现是前后都有空格或者标点符号的,那么我们就可以前后都加上 \b 来限定匹配是否出现过此单词:

str_1 = "i have an apple"
str_1 = "i have an apple, "
str_1 = "i have an apple how are you"target_pattern = r"\bapple\b"
print(re.findall(target_pattern, str_1))

2) \B-匹配空字符串,不能在开头或结尾

\B 是 \b 的取非操作,含义是匹配空字符串,但是不能出现在开头或者结尾,也就是说 \B 所在的位置必须有 1 至多个非空字符串来替代:

str_1 = "i have an apple"
target_pattern = r"app\B"
print(re.findall(target_pattern, str_1))

3) \d-匹配十进制数字

\d 用来匹配十进制数字,也就是 0-9 这些,比如下面的操作:

str_1 = "asdas98123asa978d"
target_pattern = r"\d"
print(re.findall(target_pattern, str_1))
# ['9', '8', '1', '2', '3', '9', '7', '8']

可以看到返回的结果是分隔开的数字,如果想要他们在一起返回,我们可以使用 \d+ 来操作,+ 表示的匹配 1 到 n 次,这个后面再介绍。

4) \D-匹配非十进制字符

\D 表示的是 \d 相反的操作,非十进制字符,可以使用上面的示例进行测试。

5) \s-匹配空白字符

\s 匹配的空白字符不包括标点符号,常见的有换行符,制表符,回车符等转义字符,\n \t \r \f 等

str_1 = "asdas9812\v3a\rs,.\ta9\n78\fd"
target_pattern = r"\s"
print(re.findall(target_pattern, str_1))

6) \S-匹配非空白字符

\S 是 \s 取非操作,除了上面的换行符、制表符等字符外,包括标点符号皆可被匹配上

7) \w-匹配字符

\w 不匹配换行符、制表符等转义字符,不匹配中英文常见标点符号,比如 , . ; " 等,但是可以匹配中英文字符、数字和下划线,比如下面的示例:

str_1 = "asd—— _a你‘'好,s9。8?12\v3a\rs,.\ta9\n78\fd"
target_pattern = r"\w"
print(re.findall(target_pattern, str_1))
# ['a', 's', 'd', '_', 'a', '你', '好', 's', '9', '8', '1', '2', '3', 'a', 's', 'a', '9', '7', '8', 'd']

8) \W-匹配非单词字符

\W 是 \w 的取反操作。

2. 匹配字符串出现位置

前面介绍的匹配字符串的类型,这里介绍匹配出现的位置,比如开头或者结尾。

1) \A-只匹配字符串开始

\A 只匹配字符串的开始,也就是我们所说的字符串前缀:

str_1 = "asd—— _a你‘'好,\ns9。8?12\v3a\rs,.\ta9\n78\fd"
target_pattern = r"\Aasd"
print(re.findall(target_pattern, str_1))

与字符串的 startswith() 函数在匹配功能上是一样的。

2) \Z-只匹配字符串结尾

\Z 只匹配字符串结尾部分,也就是所说的字符串后缀:

str_1 = "asd—— _a你‘'好,\ns9。8?12\v3a\rs,.\ta9\n78d"
target_pattern = r"d\Z"
print(re.findall(target_pattern, str_1))

3) ^-匹配字符串开头

^ 也是只匹配字符串的开头,但是与 \A 不同的是,使用 re.M 模式下,也可以匹配换行符后的开头,比如下面的示例,就可以返回两个结果:

str_1 = "asd—— _\na你‘'好,\ns9。8?12\v3a\rs,.\ta9\n78d"
target_pattern = r"^a"
print(re.findall(target_pattern, str_1, re.M))
# ['a', 'a']

如果去掉 re.M,则会退化成 \A 的功能

4) $-匹配字符串结尾

$ 也是只匹配字符串的结尾,但是在 re.M 模式下,也可以匹配换行符后新一行的结尾,比如下面的示例,可以返回两个结果:

str_1 = "asd—— _\na你‘'好,\ns9。8?12\v3a\rs,.\ta9d\n78d"
target_pattern = r"d$"
print(re.findall(target_pattern, str_1, re.M))

同理,如果去掉 re.M,则会退化成 \Z 的功能。

3. 匹配字符串数量

除了匹配指定模式的内容,字符位置,我们还可以匹配指定模式的数量,比如想只要满足一个即可返回,或者尽可能多的将满足的字符返回等。

接下来一一介绍如何匹配字符串数量。

1) *-匹配重复 0 到 n 次

* 表示匹配的数量可以重复从 0 到 n 次,这个 n 为任意次,尽量多的匹配字符串。

比如我们想匹配 a 以及 a 后面可以加上任意个 b 字符,比如希望 aababbabbbb 等都可以被匹配上。

那么就可以使用下面的操作:

str_1 = "axxxxabbxxxxabbbb"
target_pattern = r"ab*"
print(re.findall(target_pattern, str_1))
# ['a', 'abb', 'abbbb']

2) +-匹配重复 1 到 n 次

+ 表示匹配的数量可以重复从 1 到 n 次,提前条件是匹配模式必须出现一个。

还是上面的例子,我们希望可以匹配上 ababbb,以及无限多个 b,但是不可匹配 a,可以如下操作:

str_1 = "axxxxabbxxxxabbbb"
target_pattern = r"ab+"
print(re.findall(target_pattern, str_1))
# ['abb', 'abbbb']

3) ?-匹配重复 0 到 1 次

? 表示匹配的数量只能出现 0 到 1 次。

比如对于一个字符串,我们想匹配 apple 这个单词,但是我们也想使 apple 的复数形式 apples 也能被匹配上,所以我们这里的 s 希望它出现的次数是 0 到 1 次

str_1 = "i have an apple, he has two apples, she has three apples"
target_pattern = r"apples?"
print(re.findall(target_pattern, str_1))
# ['apple', 'apples', 'apples']

4) {}-指定匹配重复次数

使用花括号可以指定重复的次数,可以是一个固定的值,也可以是一个范围,下面分别介绍一下。

a. {m}-只匹配重复 m 次

{m} 表示匹配重复次数为 m,比如我们想要匹配 abbb,也就是 a 字符后重复出现三个 b,可以如下操作:

str_1 = "abbxxxxabbbbaxxxabbb"
target_pattern = r"ab{3}"
print(re.findall(target_pattern, str_1))
b. {m,n}-匹配重复 m 到 n 次

{m,n} 表示匹配重复次数为 m 到 n 次,比如我们想要 a 后面跟着 3,4,5个 b 都可以接受,可以如下操作:

str_1 = "abbbxxxxabbbbbbaxxxabbbb"
target_pattern = r"ab{3,5}"
print(re.findall(target_pattern, str_1))
# ['abbb', 'abbbbb', 'abbbb']

4. 匹配字符串集合

我们可以使用中括号 [] 来限定字符串或者匹配模式的集合,也就是说我们可以将我们想要匹配的字符串或者类型都加到 [] 里,满足条件的都可以被匹配返回。

1) 字符可以单独列出

如果我们想匹配某些单个字符,可以单独列出来操作,比如 a, t, w, q,可以使用 [atwq],以下是示例:

str_1 = "asdqweasdaterq"
target_pattern = r"[atwq]"
print(re.findall(target_pattern, str_1))
# ['a', 'q', 'w', 'a', 'a', 't', 'q']

2) 可以表示字符范围

我们可以使用 - 来表示字符的范围进行匹配,比如 a-z,或者数字类型的 0-9,比如下面的操作:

str_1 = "asdqweasdaterq"
target_pattern = r"[a-j]"
print(re.findall(target_pattern, str_1))
# ['a', 'd', 'e', 'a', 'd', 'a', 'e']
str_1 = "asd136q78w9ea95sd6ater"
target_pattern = r"[4-9]"
print(re.findall(target_pattern, str_1))
# ['6', '7', '8', '9', '9', '5', '6']

注意: 在这里的连接符 - 是表示范围的,如果只是想匹配 - 字符,需要使用 \ 进行转义,或者将 - 放在首位或者末位:

str_1 = "asd136q-78w-9e-a95sd6zater"
target_pattern = r"[a\-z]"
print(re.findall(target_pattern, str_1))
# ['a', '-', '-', '-', 'a', 'z', 'a']

上面的这个操作表示的是希望匹配上 - a 和 z 三个字符。

3) 特殊字符在集合里只会匹配其原始字符含义

特殊字符,比如前面表示数量的 * + 等字符在中括号里就匹配的是对应的星号和加号:

str_1 = "asdas*adas+asds(das)dasd"
target_pattern = r"[*+()]"
print(re.findall(target_pattern, str_1))
# ['*', '+', '(', ')']

4) 字符类 \s 或 \w 可以在集合里使用

比如下面的操作,可以 \W 和 0-9 之间的字符:

str_1 = "asdas*adas+asds(90123das)dasd"
target_pattern = r"[\W0-9]"
print(re.findall(target_pattern, str_1))
# ['*', '+', '(', '9', '0', '1', '2', '3', ')']

5) 取反操作可以使用 ^

如果要取反,意思是集合里的匹配模式都不匹配,比如我们想匹配字符串里的非数字,可以如下操作:

str_1 = "asdas*adas+asds(90123das)dasd"
target_pattern = r"[^\d]"
print(re.findall(target_pattern, str_1))
# ['a', 's', 'd', 'a', 's', '*', 'a', 'd', 'a', 's', 'a', 's', 'd', 's', '(', 'd', 'a', 's', ')', 'd', 'a', 's', 'd']

5. 其他匹配类型

1) |-表达式的或操作

比如我们有两个表达式 A 和 B,只要有一个符合条件即可,即匹配模式的或操作:

re.findall(r"\d+|[a-z]+", "asdas234asd2341")
# ['asdas', '234', 'asd', '2341']

2) ()-匹配括号内的任意正则表达式

小括号表示分组,可以将匹配模式分组放到多个小括号内进行匹配,匹配后的结果也会以元组的形式分组返回。

比如我们想匹配 英文字母+数字 的形式,并且以括号的形式将其分隔开,那么返回的匹配结果也会以元组的形式将其返回:

str_1 = "asdas9872"
target_pattern = r"([a-z]+)(\d+)"
result = re.findall(target_pattern, str_1)print(result)
# [('asdas', '9872')]

如果是匹配上了多个结果,那么多个结果会以列表的形式返回,元素也是匹配的结果以元组的形式返回:

str_1 = "asdas9872asdasklqw8267"
target_pattern = r"([a-z]+)(\d+)"
result = re.findall(target_pattern, str_1)print(result)
# [('asdas', '9872'), ('asdasklqw', '8267')]

3、常用正则方法

前面介绍了 re.findall() 方法,返回的是一个列表,元素是所有匹配上的结果,接下来介绍一些其他常用的正则方法。

1. re.search

re.search() 方法的作用是扫描整个目标字符串,找到匹配上的第一个位置,然后返回一个匹配对象,如果没有满足要求的数据,则返回 None。

这里要注意三点,一点是扫描整个字符串,直到找到匹配的对象,另一点是找到一个符合条件的字符串以后就停止扫描,即便后面还有符合条件的,三是返回一个匹配对象,关于匹配对象下面再介绍。

比如下面的示例是匹配 英文字母+数字:

str_1 = "..()-+/?asdas9872asdasklqw8267"
target_pattern = r"[a-z]+\d+"
result = re.search(target_pattern, str_1)
# <re.Match object; span=(8, 17), match='asdas9872'>

可以看到这里,其实有多个符合匹配模式的数据,如果这里使用 re.findall() 会返回多个值,但这里返回的只是字符串里第一个符合条件的数据。

至于如何获取返回的这个 re.Match 对象详情数据,见第四节 re.Match 匹配对象,建议先阅读该章节再往后读。

2. re.match

re.match() 方法也是用于匹配指定模式,效果上与 re.search() 无异,唯一不同的一点是 match() 方法只能从字符串的头部开始匹配,返回的也是一个 re.Match 对象。

比如下面的操作,第一种形式匹配不到数据,返回 None,第二种就可以返回 re.Match 对象:

str_1 = "..()-+/?asdas9872asdasklqw8267"
target_pattern = r"[a-z]+\d+"
result = re.match(target_pattern, str_1)
# Nonestr_1 = "asdas9872asdasklqw8267"
target_pattern = r"[a-z]+\d+"
result = re.match(target_pattern, str_1)
# <re.Match object; span=(0, 9), match='asdas9872'>

3. re.split

根据匹配模式将指定字符串进行分割,在效果上相当于 string.split() 的增强版。

因为 string.split() 不能使用正则对象来对字符串进行切割,而 re.split() 可以实现。

比如我们想要根据 1,2,3 对指定字符串进行切割,就可以用到 | 这个操作:

re.split(r"1|2|3", "as2da1s3asdsa")
# ['as', 'da', 's', 'asdsa']

我们也可以使用其他正则对象,比如我们想要根据字符串中的标点符号,空格等对字符串进行切割:

re.split(r"\W+", "i have an apple, you have two apples!")
# ['i', 'have', 'an', 'apple', 'you', 'have', 'two', 'apples', '']

re.split() 还可以接受 maxsplit 参数,表示最多切割的次数:

re.split(r"\W+", "i have an apple, you have two apples!", maxsplit=2)
# ['i', 'have', 'an apple, you have two apples!']

4. re.findall

re.findall() 前面有过介绍,根据匹配模式获取所有的匹配字符,结果以列表形式返回,元素为匹配的字符串:

re.findall(r"\d+", "asd12asxda45asd456sd23")
# ['12', '45', '456', '23']

5. re.finditer

re.finditer() 函数与 re.findall() 函数效果类似,都是找到目标字符串里全部满足条件的字符串,但是不同的是 finditer() 返回的一个迭代器,迭代器保存的是匹配对象,也就是 re.Match 对象:

for item in re.finditer(r"\d+", "asd12asxda45asd456sd23"):print(item)
# <re.Match object; span=(3, 5), match='12'>
# <re.Match object; span=(10, 12), match='45'>
# <re.Match object; span=(15, 18), match='456'>
# <re.Match object; span=(20, 22), match='23'>

6. re.sub

替换函数,将字符串里的指定模式替换成目标字符串,然后返回:

re.sub(r"\d+", "***", "asd12asxda45asd456sd23")
# 'asd***asxda***asd***sd***'

7. re.subn

re.subn() 与 re.sub() 函数作用一致,都是替换目标字符串,但是返回的是一个元组,分别是替换后的字符串和替换的次数:

re.subn(r"\d+", "***", "asd12asxda45asd456sd23")
# ('asd***asxda***asd***sd***', 4)

8. re.compile

re.compile() 函数将正则表达式编译为一个正则表达式对象,然后可以调用前面介绍过的这些正则函数,比如 re.search(),re.match(),re.findall() 等。

pattern = re.compile(r"\d+")
pattern.match("3432asdas334asd34asd")
# <re.Match object; span=(0, 4), match='3432'>

re.complie() 这个函数的操作可以用于永福匹配模式,使程序更加高效。

9. 其他参数

接下来介绍一下正则模块在匹配情况下的一些其他参数。

1) re.I

忽略大小写。

对于目标字符串,如果存在字母大小写的情况,我们可以对原始字符串统一进行大写或者小写的操作,然后进行匹配,以忽略大小写的影响,也可以使用 re.I 参数:

re.search(r"[a-z]+", "123SDAFSDsa234ASDd34".lower())
# <re.Match object; span=(3, 11), match='sdafsdsa'>re.search(r"[a-z]+", "123SDAFSDsa234ASDd34", re.I)
# <re.Match object; span=(3, 11), match='SDAFSDsa'>

2) re.M

多行匹配模式。

前面介绍 ^ 和 $ 这两个符号的匹配的时候介绍过,如果加上 re.M 参数,表示的是可以匹配字符串内部有换行符的开头和结尾的数据:

str_1 = "asd—— _\na你‘'好,\ns9。8?12\v3a\rs,.\ta9\n78d"
target_pattern = r"^a"
print(re.findall(target_pattern, str_1, re.M))
# ['a', 'a']

4、re.Match 匹配对象

对于一些函数,比如前面介绍的 re.search(),返回的就是一个 re.Match 对象,还是以上面的示例为例,如何获取 re.Match 中的数据呢,下面开始介绍。

1. Match.group()

group() 函数直接调用,或者添加参数 0,返回的是匹配的字符串数据:

print(result.group())
# asdas9872print(result.group(0))
# asdas9872

而如果我们匹配的模式使用了小括号 () 进行了分组,那么则可以对 group() 函数添加其他 index 表示匹配的分组的结果,比如下面的操作:

str_1 = "..()-+/?asdas9872asdasklqw8267"
target_pattern = r"([a-z]+)(\d+)"
result1 = re.search(target_pattern, str_1)print(result1.group(0))
# asdas9872print(result1.group(1))
# asdasprint(result1.group(2))
# 9872

2. Match.__getitem__(g)

re.Match 对象实现了 getitem 这个魔术方法,所以我们可以通过索引的方式对来访问匹配的结果,其效果和 group(index) 是一致的:

print(result1[0])
print(result1.group(0))print(result1[2])
print(result1.group(2))

3. Match.groups()

groups() 函数返回的是进行了分组匹配的结果,以元组的形式返回。

比如这里分组的 result1 对象:

print(result1.groups())
# ('asdas', '9872')

而 result 这个 Match 对象匹配模式里并没有使用小括号进行分组,所以返回的结果是空元组:

print(result.groups())
# ()

4. Match.re

返回的是生成这个 Match 对象的正则对象,也就是我们输入的 target_pattern:

print(result.re)
# re.compile('[a-z]+\\d+')

5. Match.string

返回的是传递到生成这个 Match 对象的原始字符串:

print(result.string)
# ..()-+/?asdas9872asdasklqw8267

6. Match.start() 和 Match.end()

这两个函数表示的是匹配上的字符串的开始位置和结束位置:

print(result.start(), result.end())
# 8 17

我们对原始字符串进行起始位置的截取就是 Match.group() 的结果:

print(str_1[result.start(): result.end()])
# asdas9872print(result.group())
# asdas9872

而如果我们前面对匹配模式进行了分组的操作,也就是使用了小括号,比如返回的 result1,我们可以想 start() 和 end() 函数添加索引参数分别表示这两个分组结果开始和结束的下标位置:

print(result1.groups())
# ('asdas', '9872')print(str_1[result1.start(1): result1.end(1)])
# asdasprint(str_1[result1.start(2): result1.end(2)])
# 9872

7. Match.span()

返回的是匹配结果的开始和结束位置,以元组的形式返回,其实就是一次性返回 Match.start() 和 Match.end() 的结果。

span() 函数也可以接受分组的参数返回分组的起始位置。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/diannao/6726.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【前端开发---Vue2】史上最详细的Vue2入门教程,从基础到进阶带你彻底掌握Vue(三)

本篇重点分享常见指令修饰符、v-bind指令用于 class 类名 和 style 行内样式 动态控制、v-model在其他表单元素的使用...... 并结合具体案例来让小伙伴们掌握的更透彻&#xff01;喜欢就先关注一下吧~ 声明&#xff1a;图片资源来自于黑马程序员公开学习资料 本人在学习当中&am…

golang学习笔记(协程的基础知识)

golang的协程 协程是一种轻量级的线程&#xff0c;它可以实现并发执行的并行操作。协程是Go语言中的一个核心特性&#xff0c;它使得程序能够以并发的方式运行&#xff0c;并且非常高效。与传统的线程相比&#xff0c;协程的创建和销毁成本非常低&#xff0c;可以方便地启动大…

浏览器中不能使用ES6的扩展语法...报错

浏览器大多数已经支持ES6&#xff08;ECMAScript 2015&#xff09;的扩展语法&#xff08;...&#xff09;&#xff0c;包括Chrome、Firefox、Safari和Edge等。然而&#xff0c;如果你在某些浏览器中遇到无法使用扩展语法的问题&#xff0c;可能是由以下原因导致的&#xff1a;…

致敬每一位辛勤耕耘的程序员

致敬每一位辛勤耕耘的程序员 在数字世界的浩瀚海洋中&#xff0c;有这样一群人&#xff0c;他们默默无闻&#xff0c;却用一行行代码编织出神奇的世界&#xff1b;他们日夜兼程&#xff0c;只为让科技的力量更贴近人们的生活。他们&#xff0c;就是我们最可爱的程序员们。今天…

神经网络之防止过拟合

今天我们来看一下神经网络中防止模型过拟合的方法 在机器学习和深度学习中&#xff0c;过拟合是指模型在训练数据上表现得非常好&#xff0c;但在新的、未见过的数据上表现不佳的现象。这是因为模型过于复杂&#xff0c;以至于它学习了训练数据中的噪声和细节&#xff0c;而不…

一款开源高性能AI应用框架

前言 LobeChat 是一个基于 Next.js 框架构建的 AI 会话应用&#xff0c;旨在提供一个 AI 生产力平台&#xff0c;使用户能够与 AI 进行自然语言交互。 LobeChat应用架构 LobeChat 的整体架构由前端、EdgeRuntime API、Agents 市场、插件市场和独立插件组成。这些组件相互协作&a…

代码随想录算法训练营二刷第14天 | 二叉搜索树完结

235.二叉搜索树的最近公共祖先 要记住 二叉搜索树自带搜索方向 这个特性&#xff01;要找 二叉搜索树的最近公共祖先&#xff0c;那么相当于就是二叉搜索树的搜索&#xff0c;要想到“二叉搜索树的搜索”的迭代法其实是利用了二叉树的特性的&#xff0c;那么&#xff0c;本题也…

P8799 [蓝桥杯 2022 国 B] 齿轮

P8799 [蓝桥杯 2022 国 B] 齿轮 分析 最右边的齿轮的转速是最左边齿轮的q倍 最右边的齿轮的半径是最左边齿轮的q倍 题意即为&#xff1a;查询数组中是否存在两个数&#xff0c;其中一个是另一个的q倍 题目范围&#xff1a;查询次数q:2*10^5&#xff0c;数组范围2*10^5&…

XXL-JOB定时任务

1. xxl-job初识 1.1 xxl-job介绍 xxl-job 是大众点评大佬徐雪里开源的一款分布式任务调度框架&#xff0c;具有简单易用、轻量级、可扩展的特点。相比于Spring Task, Quartz&#xff0c;xxl-job有记录执行日志和运行大盘&#xff0c;方便开发人员和运维人员更好的管理任务。 …

Docker no space left on device

Docker no space left on device 原因&#xff1a;空间不足 解决方式&#xff1a;清理空间,删除未被使用的容器&#xff0c;镜像等资源 docker system prune -a Docker是一种相对使用较简单的容器&#xff0c;我们可以通过以下几种方式获取信息&#xff1a; 1、通过docker ru…

如何进行面向对象分析、面向对象设计和面向对象编程

目录 1.引言 2.案例介绍和难点剖析 3.如何进行面向对象分析 4.如何进行面向对象设计 5.如何进行面向对象编程 6.总结 1.引言 面向对象分析(OOA)、面向对象设计(00D)和面向对象编程(OOP)是面向对象开发的3个主要环节。 在以往的工作中&#xff0c;作者发现&#xff0c;很多…

【JavaEE 初阶(一)】初识线程

❣博主主页: 33的博客❣ ▶️文章专栏分类:JavaEE◀️ &#x1f69a;我的代码仓库: 33的代码仓库&#x1f69a; &#x1faf5;&#x1faf5;&#x1faf5;关注我带你了解更多线程知识 目录 1.前言2.进程3.线程4.线程和进程的区别5.Thread创建线程5.1继承Thread创建线程5.2实现R…

为什么Java的id用long但是做JavaWeb项目时id用String而不是long

为什么Java中id用long? 1.从整数的范围来看 int: 最小值&#xff1a;-2,147,483,648 最大值&#xff1a;2,147,483,647 在Java中&#xff0c;int类型是32位有符号整数&#xff0c;范围是从 -2^31 到 2^31-1。 long: 最小值&#xff1a;-9,…

专项技能训练五《云计算网络技术与应用》实训7-2:使用OpenDaylight界面下发流表

文章目录 使用OpenDaylight的web界面下发流表1. 根据前面实训教程&#xff0c;启动并登录到opendaylight的web控制页面&#xff0c;并使用mininet2. 单击左侧的“Nodes”查看节点信息。其中尤其需要关注Node Id&#xff0c;下发流表的时候会用到Node Id&#xff0c;如下图所示。…

怎么查看java 安装路径

查看Java安装路径的方法因操作系统而异。以下是几种常见操作系统中查看Java安装路径的方法&#xff1a; Windows系统&#xff1a; 使用命令提示符&#xff1a; 打开命令提示符&#xff08;cmd&#xff09;。输入以下命令&#xff1a;for %i in (java.exe) do echo %~$PATH:i。…

无穷级数错题本

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 <

word中取消分页符或分段符前后的空格

在Word中&#xff0c;有时候&#xff0c;我们添加分页符后&#xff0c;从分页符后面的文字就全部掉到了下一页&#xff0c;那么如何避免呢&#xff1f; 选择word选项--高级&#xff0c;然后下滑到下面&#xff0c;将“取消分页符或分段符前后的空格”选中&#xff0c;如下图所…

解读简单的一段深度学习代码(已跑通)

最近一直想要学习深度学习的内容&#xff0c;想要复现大佬的代码&#xff0c;试了好多有的是不给数据&#xff0c;有的总是跑不通&#xff0c;这一个是已经跑通的一个代码&#xff0c;以上为证&#xff0c;学习最快的方式就是直接实战&#xff0c;大部分的内容都是比较偏向于理…

机器学习笔记导航(吴恩达版)

01.机器学习笔记01&#xff1a;机器学习前置概念导入、线性回归、梯度下降算法 02.机器学习笔记02&#xff1a;多元线性回归、多元梯度下降算法、特征缩放、均值归一化、正规方程 03.机器学习笔记03&#xff1a;octave安装、创建矩阵 04.机器学习笔记04&#xff1a;octave中移动…

etcdv3.6源码流程---Get

线性一致性需要满足的要求&#xff1a; 1.任何一次读都能读到某个数据的最近一次写的数据。即每次都是直接读最新的数据 2.系统中的所有进程&#xff0c;看到的操作顺序&#xff0c;都与全局时钟下的顺序一致。一旦某个请求在时刻a读到了版本为b的某个值&#xff0c;那么时刻a以…