正則運算式python非加倍組模式-有解無憂

有人可以看看這個正則運算式嗎？

PATTERN=r"([A-Z]{3}[\/I\\\s\-\|]?[A-Z]{3})\s*(BUY|SELL) \s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*((SL|TP)?\s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*(?:(\(?))((-\d |\d \ |\d )?\s*Pips)?(?:\))?)?\s*((SL|TP)?\s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*(?:(\(?))((-\d |\d \ |\d )?\s*Pips)?(?:\))?)?\s*(Intra-Day Trade|SWING TRADE)?\s*"gm

有什么方法可以將多個組匹配為 SL 或 TP 而無需重寫整個

((SL|TP)?\s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*(?:(\(?))((-\d |\d \ |\d )?\s*Pips)?(?:\))?)?

小組的模式？

我正在嘗試獲取 SL 和 TP 組（在這種情況下）：示例：

import re
PATTERN=r"([A-Z]{3}[\/I\\\s\-\|]?[A-Z]{3})\s*(BUY|SELL) \s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*((SL|TP)?\s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*(?:(\(?))((-\d |\d \ |\d )?\s*Pips)?(?:\))?)?\s*((SL|TP)?\s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*(?:(\(?))((-\d |\d \ |\d )?\s*Pips)?(?:\))?)?\s*(Intra-Day Trade|SWING TRADE)?\s*"
text="""EURCAD SELL 1.36599 SL 1.37701 (110 Pips) TP 1.34017 (258 Pips) Intra-Day Trade """
match = re.match(PATTERN, text)
groups = list(match.groups())
for idx, x in enumerate(groups):
  print(f"Group number {idx}, content: {x}")

輸出：

Group number 0, content: EURCAD
Group number 1, content: SELL
Group number 2, content: 1.36599
Group number 3, content: SL 1.37701 (110 Pips)
Group number 4, content: SL
Group number 5, content: 1.37701
Group number 6, content: (
Group number 7, content: 110 Pips
Group number 8, content: 110
Group number 9, content: TP 1.34017 (258 Pips)
Group number 10, content: TP
Group number 11, content: 1.34017
Group number 12, content: (
Group number 13, content: 258 Pips
Group number 14, content: 258
Group number 15, content: Intra-Day Trade

組不重復代碼：

import re
PATTERN=r"([A-Z]{3}[\/I\\\s\-\|]?[A-Z]{3})\s*(BUY|SELL) \s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*((SL|TP)?\s*(-\d \.\d |\d \.\d \ |\d \.\d )?\s*(?:(\(?))((-\d |\d \ |\d )?\s*Pips)?(?:\))?) \s*\s*(Intra-Day Trade|SWING TRADE)?\s*"
text="""EURCAD SELL 1.36599 SL 1.37701 (110 Pips) TP 1.34017 (258 Pips) Intra-Day Trade """
match = re.match(PATTERN, text)
groups = list(match.groups())
for idx, x in enumerate(groups):
  print(f"Group number {idx}, content: {x}")

輸出非重復代碼：

Group number 0, content: EURCAD
Group number 1, content: SELL
Group number 2, content: 1.36599
Group number 3, content: 
Group number 4, content: TP
Group number 5, content: 1.34017
Group number 6, content: 
Group number 7, content: 258 Pips
Group number 8, content: 258
Group number 9, content: Intra-Day Trade

但是如果不將它們分布在兩個不同的組之間，我就無法做到這一點。非不同組regex101 鏈接的示例。這顯然給了我：

我必須匹配：

EURCAD SELL 1.36599
SL 1.37701 (110 Pips)
TP 1.34017 (258 Pips)
Intra-Day Trade

但是也（-）：

EURCAD SELL 1.36599
SL 1.37701 (110 Pips)
Intra-Day Trade

(-)

EURCAD SELL 1.36599
TP 1.34017 (258 Pips)
Intra-Day Trade

(-)

EURCAD SELL 1.36599

(-)

EURCAD SELL 1.36599
SL 1.37701 (110 Pips)
TP 1.34017 (258 Pips)

(-)

EURCAD SELL 1.36599
SL 1.37701 (110 Pips)
TP 1.34017 (258 Pips)

SWING TRADE

(-)

EUR/CAD BUY 1.36599
SWING TRADE

(-)

EUR|CAD BUY 1.36599
SWING TRADE

(-)

EUR\CAD BUY 1.36599
SWING TRADE

(-)

EUR|CAD BUY 1.36599
SWING TRADE

(-)

EURICAD BUY 1.36599
Intra-Day Trade

基本上這些是人工輸入的字串，我必須提供所有可能導致正確“交易”信號的匹配項。

顯然，通過閱讀正則運算式，您可以獲得我想要匹配的內容，但我并沒有真正尋求正則運算式模式的幫助，而只是尋求 GROUPS 語法的幫助（如果沒有重復代碼，它不會導致正確的匹配） .

這是模式的regex101 鏈接，供您自行測驗。先感謝您。

uj5u.com熱心網友回復：

如果您正在重復捕獲組，則捕獲組具有最后一次迭代的值。

您嘗試的模式可以縮短為：

([A-Z]{3}[\/I\\\s|-]?[A-Z]{3})\s*(BUY|SELL) \s*(-?\d \.\d |\d \.\d \ )?(?:\n(SL|TP)\s*(-?\d \.\d |\d \.\d \ )\s*(\((-?\d |\d \ )?\s*Pips\)))*\s*(Intra-Day Trade|SWING TRADE)?

關于縮短模式的一些注意事項：

這部分(?:(\(?))可以寫成\(?
這部分(-\d \.\d |\d \.\d \ |\d \.\d )可以寫成(-?\d \.\d |\d \.\d \ )
Pips 部分中的括號 like(110 Pips)不是可選的
對于非重復模式，您使用所有可選部分將非捕獲組重復了 1 次或多次。相反，您可以選擇以固定格式重復非捕獲組，以便所有內部部分都不是可選的

如果要重復捕獲組并具有這些值，并且可以使用PyPi 正則運算式模塊，則可以使用capturesdict()和使用命名捕獲組

具有命名捕獲組的模式：

(?P<word1>[A-Z]{3}[\/I\\\s|-]?[A-Z]{3})\s*(?P<word2>BUY|SELL) \s*(?P<word3>-?\d \.\d |\d \.\d \ )?(?:\n(?P<word4>SL|TP)\s*(?P<word5>-?\d \.\d |\d \.\d \ )\s*(?P<word6>\((-?\d |\d \ )?\s*Pips\)))*\s*(?P<wor7>Intra-Day Trade|SWING TRADE)?

正則運算式演示| Python 演示

例如

import regex

pattern = r"(?P<word1>[A-Z]{3}[\/I\\\s|-]?[A-Z]{3})\s*(?P<word2>BUY|SELL) \s*(?P<word3>-?\d \.\d |\d \.\d \ )?(?:\n(?P<word4>SL|TP)\s*(?P<word5>-?\d \.\d |\d \.\d \ )\s*(?P<word6>\((-?\d |\d \ )?\s*Pips\)))*\s*(?P<wor7>Intra-Day Trade|SWING TRADE)?"

s = ("EURCAD SELL 1.36599\n"
            "SL 1.37701 (110 Pips)\n"
            "TP 1.34017 (258 Pips)\n\n"
            "Intra-Day Trade\n\n"
            "EUR/CAD BUY 1.36599\n"
            "SWING TRADE")

matches = regex.finditer(pattern, s, regex.M)

for matchNum, match in enumerate(matches, start=1):
    print(match.capturesdict())

輸出

{'word1': ['EURCAD'], 'word2': ['SELL'], 'word3': ['1.36599'], 'word4': ['SL', 'TP'], 'word5': ['1.37701', '1.34017'], 'word6': ['(110 Pips)', '(258 Pips)'], 'wor7': ['Intra-Day Trade']}
{'word1': ['EUR/CAD'], 'word2': ['BUY'], 'word3': ['1.36599'], 'word4': [], 'word5': [], 'word6': [], 'wor7': ['SWING TRADE']}

轉載請註明出處，本文鏈接：https://www.uj5u.com/shujuku/485676.html

標籤：Python 正则表达式正则表达式组

上一篇：正則運算式使用可能是值對一部分的分隔符決議多個鍵對值

下一篇：查找具有不同結尾的子字串