python 歷險記(六）— python 對正則表達式的使用（上篇）

来源:https://www.cnblogs.com/reycg-blog/archive/2018/11/26/10018017.html
-Advertisement-
Play Games

[TOC] 引言 剛接觸正則表達式，我也曾被它們天書似的符號組合給嚇住，但經過一段時間的深入學習，發現它並沒有想象中那麼可怕，只要多實踐，多理解，也是可以輕鬆搞定的。 而且我發現帶著問題去學習，求知欲會驅使著你往前走，不知不覺就懂了。 下麵就是我在學習中提出的幾個問題，在後面會依次進行討論。由於正則 ...


目錄

引言

剛接觸正則表達式，我也曾被它們天書似的符號組合給嚇住，但經過一段時間的深入學習，發現它並沒有想象中那麼可怕，只要多實踐，多理解，也是可以輕鬆搞定的。
而且我發現帶著問題去學習，求知欲會驅使著你往前走，不知不覺就懂了。
下麵就是我在學習中提出的幾個問題，在後面會依次進行討論。由於正則表達式涉及到的內容確實非常多，分成兩篇來闡述。

  1. 什麼是正則表達式？
  2. 正則表達式可以乾什麼？
  3. 正則表達式的語法以及在 python 中這些語法是如何使用的？
  4. 正則表達式如何處理中文字元？
  5. python 的正則表達式庫中有哪些重要的函數？

什麼是正則表達式？

正則表達式使用單個字元串來描述，匹配一系列符合某個句法規則的字元串。

— 維基百科

先來劃重點：

  1. 正則表達式的表現形式是 單個字元串
  2. 它用來執行匹配的動作
  3. 匹配的對象也是字元串

語言總是有些蒼白的,必須要結合實例才能理解的更清楚，先來看一個例子:

>>> import re
>>>re.search(r'wo\w+d', 'hello world!')
<re.Match object; span=(6, 11), match='world'>
>>>

這裡先概略說明 re.search 方法：引入的 re 模塊就是 python 的正則表達式模塊，re.search 函數目的就是接受一個正則表達式和一個字元串，並以 Match 對象的形式返回匹配的第一個元素。如果沒有匹配到，則會返回 None。(關於 search 函數先瞭解這些就可以，後面會有詳細講解。)

下麵就拿這個示例中 re.search 中的參數來匹配下上面的概念,加深一下理解

  • 'wo\w+d' 就是正則表達式，它還有一個名稱叫做_模式(pattern)_ ，表示wo 字母後有多個字母並一直到d 字母出現為止（現在不明白沒關係，只要知道它就是正則表達式就可以了，後面會詳細講）
  • 在 'wo\w+d' 前面還有一個 r 表示什麼呢？這個 r 表示 raw的意思，就是原始字元串。原始字元串不會將 \ 解釋成一個轉義字元，而是這樣做對正則表達式好處是大大的，只有這樣 \w 才能起作用。
  • 'hello world!' 就是要匹配的字元串。
  • 整個函數就表示從 'hello world!' 字元串中搜索出符合_'wo\w+d'_ 模式的字元串，並展示出來，於是 world 字元串就被篩選了出來。

正則表達式有什麼用？

我們學習正則表達式的目的是什麼？當然是為了有朝一日能使用它解決我們面臨的問題，要不然，學它幹嘛。那我們就來聊聊正則表達式的用途：

  • 字元串驗證

    你肯定在網頁上註冊過賬號吧，假如你在註冊 github 網站，它要求你輸入 Email，而你卻胡亂填寫了幾個數字就想註冊，這時就會彈出提示 "Email is invalid"，意思就是你的郵箱是無效的，這就是正則表達式的功勞。

  • 替換文本

    假如你正在寫一篇關於 java 的文章，寫著寫著，你覺得換成 python 更好些，你想一下把出現 java , Java 的地方全都替換成 python ， 正則表達式可以幫你做到。

  • 從字元串中提取出要獲取的字元串

    假如你正在爬取一個汽車排行榜頁面，想要獲取每個車型的編號，而車型編號則隱藏在鏈接中，怎麼獲取呢？用正則表達式可以。

正則表達式的語法及使用實例

對剛接觸的同學來說，正則表達式的語法很晦澀。不用擔心，我們先大致瀏覽一下完整的語法組合，後面再使用前面講過的 re.search 方法一個個詳細介紹，講著講著，我相信你就明白了。

正則表達式語法有哪些？

字元 功能描述
\ 特殊字元轉義
^ 匹配字元串的開始位置
$ 匹配字元串的結束位置
* 匹配前面的子表達式零次或多次
+ 匹配前面的子表達式一次或多次
? 匹配前面的子表達式零次或一次
{n} n是非負整數，匹配n次
{n,} n 是非負整數，匹配 >=n 次
{n,m} m是非負整數，n<=m, 匹配>= n 並且 <=m 次
? 非貪心量化
. 匹配除“\r”“\n”之外的任何單個字元
(pattern) 匹配pattern並獲取這一匹配的子字元串
(?:pattern) 非獲取匹配
(?=pattern) 正向肯定預查
(?!pattern) 正向否定預查
(?<=pattern) 反向（look behind）肯定預查
(?<!pattern) 反向否定預查
x|y 沒有包圍在()里，其範圍是整個正則表達式
[xyz] 字元集合（character class），匹配所包含的任意一個字元
[^xyz] 排除型字元集合（negated character classes），匹配未列出的任意字元
[a-z] 字元範圍，匹配指定範圍內的任意字元
[^a-z] 排除型的字元範圍，匹配任何不在指定範圍內的任意字元
\b 匹配一個單詞邊界，也就是指單詞和空格間的位置
\B 匹配非單詞邊界
\cx 匹配由x指明的控制字元
\d 匹配一個數字字元。等價於[0-9]
\D 匹配一個非數字字元。等價於[^0-9]。
\f 匹配一個換頁符。等價於\x0c和\cL。
\n 匹配一個換行符。等價於\x0a和\cJ。
\r 匹配一個回車符。等價於\x0d和\cM。
\s 匹配任何空白字元。等價於[ \f\n\r\t\v]
\S 匹配任何非空白字元。等價於[^ \f\n\r\t\v]。
\t 匹配一個製表符。等價於\x09和\cI。
\v 匹配一個垂直製表符。等價於\x0b和\cK。
\w 匹配包括下劃線的任何單詞字元。等價於“[A-Za-z0-9_]”
\W 匹配任何非單詞字元。等價於“[^A-Za-z0-9_]”。
\ck 匹配控制轉義字元。k代表一個字元。等價於“Ctrl-k”
\xnn 十六進位轉義字元序列
\n 標識一個八進位轉義值或一個向後引用
\un Unicode轉義字元序列

這些正則到底該怎麼用？

瀏覽一遍，感覺怎麼樣，是不是摩拳擦掌，想要立刻實踐一番，嘿嘿。好的我們現在就開乾。

  • ^ 匹配字元串的開始位置

    >>> import re
>>> re.search(r'^h', 'he is a hero!')          
<re.Match object; span=(0, 1), match='h'>

    這個例子中雖然有兩個 h，因為前面有 ^ 所以只會匹配第一個

  • $ 匹配字元串的結束位置

    >>> import re

>>> re.search(r't$','this is an object')

<re.Match object; span=(16, 17), match='t'>

    雖然這個句子前後都有 t,卻是最後的被匹配到了

  • * 匹配前面的子表達式 0 次或多次，例如，"zo*" 能匹配"z","zo","zoo",我們來驗證下

    >>> import re

>>> re.search(r'zo*', 'z')

<re.Match object; span=(0, 1), match='z'>
>>> re.search(r'zo*', 'zo')

<re.Match object; span=(0, 2), match='zo'>
>>> re.search(r'zo*', 'zoo')

<re.Match object; span=(0, 3), match='zoo'>

    ​ 這裡 * 還有一種寫法 {0,}，兩者等價。其中 {} 叫做重覆。來看例子。

    import re
re.search(r'zo{0,}','z')
<_sre.SRE_Match object; span=(0, 1), match='z'>
re.search(r'zo{0,}','zo')
<_sre.SRE_Match object; span=(0, 2), match='zo'>
re.search(r'zo{0,}','zoo')
<_sre.SRE_Match object; span=(0, 3), match='zoo'>

  • + 匹配前面的子表達式一次或多次,以 "zo+" 為例，它能匹配 "zo","zoo",來驗證下

    >>> import re
>>> re.search(r'zo+', 'zo')

<re.Match object; span=(0, 2), match='zo'>
>>> re.search(r'zo+', 'zoo')

<re.Match object; span=(0, 3), match='zoo'>

    這裡 + 還有一種寫法 {1,} 兩者是等價的，來看例子。

    >>> import re

>>> re.search(r'zo{1,}','zo')

<re.Match object; span=(0, 2), match='zo'>

>>> re.search(r'zo{1,}','zoo')

<re.Match object; span=(0, 3), match='zoo'>

  • ? 匹配前面的子表達式0次或 1次，以 "ab(cd)?" 為例，可以匹配 "ab","abcd"，看下麵例子

    import re
re.search(r'ab(cd)?','ab')
<_sre.SRE_Match object; span=(0, 2), match='ab'>
re.search(r'ab(cd)?','abcd')
<_sre.SRE_Match object; span=(0, 4), match='abcd'>

    這裡 ? 還有一種寫法 {0,1} 兩者等價，看下麵

    import re
re.search(r'ab(cd){0,1}', 'ab')
<_sre.SRE_Match object; span=(0, 2), match='ab'>
re.search(r'ab(cd){0,1}', 'abcd')
<_sre.SRE_Match object; span=(0, 4), match='abcd'>

  • {n} n 必須是非負整數，能匹配確定的 n 次，以 "o{2}" 為例，它能匹配 "good", 卻不能匹配 "god"

    import re
re.search(r'o{2}', 'god')
re.search(r'o{2}', 'good')
<_sre.SRE_Match object; span=(1, 3), match='oo'>

  • {n,} n是一個非負整數。至少能匹配 n次。例如，“o{2,}”不能匹配 “god”中的 “o”，但能匹配“foooood”中的所有o。“o{1,}”等價於“o+”。“o{0,}”則等價於“o*”，這個可看前面示例。

  • {n,m} m和n均為非負整數，其中n<=m。例如，“o{1,2}”將匹配“google”中的兩個o。“o{0,1}”等價於“o?”。註意在逗號和兩個數之間不能有空格

    re.search(r'o{1,2}', 'google')
<_sre.SRE_Match object; span=(1, 3), match='oo'>

  • ? 這個叫做非貪心量化（Non-greedy quantifiers），這個字元和前面的 ? 有什麼區別？應用場合是什麼呢？

    當該字元緊跟在任何一個其他重覆修飾符（*,+,?，{n}，{n,}，{n,m}）後面時，匹配模式是非貪婪的。非貪婪模式儘可能少的匹配所搜索的字元串，而預設的貪婪模式則儘可能多的匹配所搜索的字元串。舉個例子，"o+" 預設會匹配 o 一次或多次，如果在後面加上 "?"，則匹配一次。來看代碼。

    re.search(r'o+?', 'google')
<_sre.SRE_Match object; span=(1, 2), match='o'>
re.search(r'o+', 'google')
<_sre.SRE_Match object; span=(1, 3), match='oo'>

  • . 匹配除了 \r ,\n 之外的任何單個字元,要匹配包括“\r”“\n”在內的任何字元，請使用像“(.|\r|\n)”的模式

    import re
re.search(r'a.', 'ab')
<_sre.SRE_Match object; span=(0, 2), match='ab'>

  • (pattern) 匹配 pattern 並獲取這一匹配的子字元串，並用於向後引用。使用圓括弧可以指定分組。當使用分組時，除了獲取到整個匹配的完整字元串，也可以從匹配中選擇每個單獨的分組。

    下麵給出一個本地電話號碼的示例，其中每個括弧內匹配的數字都是一個分組。

    >>> import re
>>> match = re.search(r'([\d]{3,4})-([\d]{7,8})', '010-12345678')
>>> match
<re.Match object; span=(0, 12), match='010-12345678'>
>>> match.group(1)
'010'
>>> match.group(2)
'12345678'
>>> match.group()
'010-12345678'
>>> match.groups()
('010', '12345678')

    前面我們只是簡單介紹了 match 對象，為了深入的理解分組，這裡還要簡單介紹下該對象的幾個方法以及如何對應分組信息的：

    • groups() 用於返回一個對應每一個單個分組的元組。

      >>> match.groups()
('010', '12345678')

    • group() 方法(不含參數)則返回完整的匹配字元串

      >>> match.group()
'010-12345678'

    • group(num) num 是分組編號，按照分組順序，從 1 開始取值，能獲取具體的分組數據。

      >>> match.group(1)
'010'
>>> match.group(2)
'12345678'

  • (?:pattern) 匹配 pattern 但不獲取匹配的子字元串（shy groups），也就是說這是一個非獲取匹配，不存儲匹配的子字元串用於向後引用。這種格式的圓括弧不會作為分組信息，只用於匹配，即在python 調用search 方法而得到的 match 對象不會將圓括弧作為分組存儲起來。

    來看下麵例子，只獲取電話號，而不獲取地區區號。

    >>> match = re.search(r'(?:[\d]{3,4})-([\d]{7,8})', '010-12345678')
>>> match.groups()
('12345678',)
>>> match.group()
'010-12345678'

    這種形式對使用 或 字元`(|)”來組合一個模式的各個部分是很有用的，來看一個例子，想要同時匹配 city 和 cities (複數形式)，就可以這樣乾

    >>> match = re.search(r'cit(?:y|ies)','cities')
>>> match
<re.Match object; span=(0, 6), match='cities'>
>>> match = re.search(r'cit(?:y|ies)','city')
>>> match
<re.Match object; span=(0, 4), match='city'>

  • (?=pattern)正向肯定預查（look ahead positive assert），在任何匹配 pattern 的字元串開始處匹配查找字元串。這是一個非獲取匹配，也就是說，該匹配不需要獲取供以後使用。

    舉個例子，假設我要獲取從不同 python 版本中只獲取 "python" 字元串，就可以這樣寫:

    >>> match = re.search(r'python(?=2.7|3.5|3.6|3.7)', 'python3.7')
>>> match
<re.Match object; span=(0, 6), match='python'>

    預查不消耗字元，也就是說，在一個匹配發生後，在最後一次匹配之後立即開始下一次匹配的搜索，而不是從包含預查的字元之後開始。那麼在 python 版本後再加上其他信息，整體就無法匹配了。

    看下麵例子，得到的結果只能是 null。

    >>> match = re.search(r'python(?=2.7|3.5|3.6|3.7) is hacking!', 'python3.7 is hacking!')
>>> match

  • (?!pattern) 正向否定預查（negative assert），看名字也知道是 正向肯定預查的反面。在任何不匹配 pattern 的字元串開始處匹配查找字元串。是一個非獲取匹配，而且預查不消耗字元。

    看下麵例子，和正向肯定預查一對比就明白了。

    >>> match = re.search(r'python(?!2.7|3.5|3.6|3.7)', 'python3.7')
>>> match
>>> match = re.search(r'python(?!2.7|3.5|3.6|3.7)', 'python3.1')
>>> match
<re.Match object; span=(0, 6), match='python'>
>>> match = re.search(r'python(?!2.7|3.5|3.6|3.7) is hacking!', 'python3.1 is hacking!')
>>> match

  • (?<=pattern) 反向（look behind）肯定預查，與正向肯定預查類似，只是方向相反。

  • (?<!pattern) 反向否定預查，與正向否定預查類似，只是方向相反。

  • x|y 或，分兩種情況：沒有沒括弧包圍，範圍則是整個表達式；被括弧包圍，返回是括弧內。

    >>> match = re.search(r'today is sunday|tommory is monday','tommory is monday')
>>> match
<re.Match object; span=(0, 17), match='tommory is monday'>

  • [xyz] 字元集合，匹配所包含的任意一個字元。分為下麵情況

    • 普通字元

      >>> match = re.search(r'[Pp]ython','python')
>>> match
<_sre.SRE_Match object; span=(0, 6), match='python'>

    • 特殊字元僅有反斜線 \保持特殊含義，用於轉義字元

    • 其它特殊字元如星號、加號、各種括弧等均作為普通字元

      >>> match = re.search(r'[*?+()]python','*python')
>>> match
<_sre.SRE_Match object; span=(0, 7), match='*python'>
>>> match = re.search(r'[*?+()]python','+python')
>>> match
<_sre.SRE_Match object; span=(0, 7), match='+python'>
>>> match = re.search(r'[*?+()]python','(python')
>>> match
<_sre.SRE_Match object; span=(0, 7), match='(python'>

    • ^ 出現在字元串中間和末尾僅作為普通字元，出現在最前面後面會講。

      >>> match = re.search(r'[*^{]python','^python')
>>> match
<_sre.SRE_Match object; span=(0, 7), match='^python'>
>>> match = re.search(r'[*^]python','^python')
>>> match
<_sre.SRE_Match object; span=(0, 7), match='^python'>

    • - 出現在字元集合首位和末尾，僅作為普通字元，出現在中間是字元範圍描述，後面會講。

      >>> match = re.search(r'[-^]python','-python')
>>> match
<_sre.SRE_Match object; span=(0, 7), match='-python'>

  • [^xyz] 排除型字元集合（negated character classes）。匹配未列出的任意字元

    >>> re.search(r'[^abc]def','edef')

<re.Match object; span=(0, 4), match='edef'>

  • [a-z] 字元範圍。匹配指定範圍內的任意字元。

    >>> re.search(r'[a-g]bcd','ebcd')

<re.Match object; span=(0, 4), match='ebcd'>
>>> re.search(r'[a-g]bcd','hbcd')

  • [^a-z] 排除型的字元範圍。匹配任何不在指定範圍內的任意字元。

    >>> re.search(r'[^a-g]bcd','hbcd')

<re.Match object; span=(0, 4), match='hbcd'>

  • \b 匹配一個單詞邊界，也就是指單詞和空格間的位置。

    >>> re.search(r'an\b apple','an apple')

<re.Match object; span=(0, 8), match='an apple'>

  • \B 匹配非單詞邊界

    >>> re.search(r'er\B','verb')

<re.Match object; span=(1, 3), match='er'>

  • \d 匹配一個數字字元。等價於[0-9]

    >>> re.search(r'\d apples', '3 apples')

<re.Match object; span=(0, 8), match='3 apples'>

  • \D 匹配一個非數字字元。等價於[^0-9]

    >>> re.search(r'\D dog', 'a dog')

<re.Match object; span=(0, 5), match='a dog'>

  • \s 匹配任何空白字元，包括空格、製表符、換頁符等等。等價於[ \f\n\r\t\v]。

    >>> re.search(r'a\sdog', 'a dog')

<re.Match object; span=(0, 5), match='a dog'>

  • \S 匹配任何非空白字元。等價於[^ \f\n\r\t\v]

    >>> re.search(r'\S dog', 'a dog')

<re.Match object; span=(0, 5), match='a dog'>

  • \w 匹配包括下劃線的任何單詞字元。等價於“[A-Za-z0-9_]”

    >>> re.search(r'\w', 'h')

<re.Match object; span=(0, 1), match='h'>

  • \W 匹配任何非單詞字元。等價於“[^A-Za-z0-9_]”

    >>> re.search(r'\W', '@')

<re.Match object; span=(0, 1), match='@'>

  • \un Unicode轉義字元序列。其中n是一個用四個十六進位數字表示的Unicode字元

    >>> re.search(r'\u00A9','©')

<re.Match object; span=(0, 1), match='©'>

小結

如果你真的讀完了這些實例，我敢說你對正則表達式會有一定的理解了吧。下篇會重點講解python 中的正則表達式庫函數，對中文的處理等，敬請期待~

參考文檔

  1. 維基百科—正則表達式

系列文章列表


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • CSS3 過渡、變形和動畫
    一、我們來給按鈕增加一個懸停效果：#content a:hover {border: 1px solid #000000;color: #000000;text-shadow: 0px 1px white;}兩種狀態下的效果如下，先看預設狀態： 再看懸停狀態： 這裡只是在滑鼠懸停時簡單地修改了一下文 ...
  • Vue packages version conflicts 錯誤修複
    我們在使用Vue作為weex中的前端框架的開發過程中，某次 npm start 遇到瞭如下的錯誤： Vue packages version mismatch: - [email protected] - [email protected] This may cause things to ...
  • 圖片圓角並居中顯示解決方案
    1、圖片圓角顯示 例如（非常簡單）： HTML： CSS： 如果圖片只為圓角，這種方式確實沒問題，但如果還要加上居中的效果，這種方式就有問題，下麵會說明。 2、圖片居中顯示（鋪滿父容器且不變形） 效果圖如下： PS：為了實現上圖居中的效果，單靠CSS是不行的，還需要JS處理。 例如： HTML： C ...
  • web前端開發需要的資料
    以前有小伙伴自己做了個小游戲，類似掃雷這種，都覺得簡單好玩，老師還提名錶揚呢，那時沒深究是怎麼開發的，現在想想就是純前端的簡單小游戲啊。 工作後，發現前端才是王道啊，先不說大家說的什麼“整個互聯網都缺前端啊”這種話題，就說要抓取用戶眼球，讓用戶有點擊的欲望，這都是前端工作啊，畢竟用戶才不關心“你咋實 ...
  • js基礎梳理-究竟什麼是執行上下文棧（執行棧），執行上下文(可執行代碼）？
    日常在群里討論一些概念性的問題，比如變數提升，作用域和閉包相關問題的時候，經常會聽一些大佬們給別人解釋的時候說執行上下文，調用上下文巴拉巴拉，總有點似懂非懂，不明覺厲的感覺。今天，就對這兩個概念梳理一下，加深對js基礎核心的理解。 1. 執行上下文(execution context)與可執行代碼（ ...
  • HTML5拖拽/拖放(drag & drop)詳解
    H5中拖拽屬性： draggable： auto | true | false 拖動事件： - dragstart 在元素開始被拖動時觸發 - dragend 在拖動操作完成時觸發 - drag 在元素被拖動時觸發 釋放區事件： ...
  • DOM基礎練習代碼（二）
    上一篇給大家的三段代碼不知到大家有沒有練習呢？今天再給大家帶來兩段DOM的練習！ 4.封裝函數，實現children功能，最好哎原型鏈上編程 ...
  • Bootloader的結構和啟動過程
    CPU上電後，會在某個地址開始執行，比如MIPS結構的CPU會從0xBFC00000取第一條指令，而ARM結構的CPU則從0x00000000開始，嵌入式開發板中，需要把存儲器件ROM或Flash等映射到這個地址。而Bootloader就存在這個地址的開始處，這樣一上電後就會從這個地址處執行。Boo ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類