I got all of them to match using this (You'll need to add the case-insensitive flag):

(^[a-z][a-z\'&\(\) ]+\bv\b[a-z&\'\(\) ]+(?:.*?) \[?\d+ \w+ \d{4}\]?)

Regex Demo

Explanation:

• ( Begin capture group
  • [a-z\'&\(\) ]+ Match one or more of the characters in this group
  • \b Match a word boundary
  • v Match the character 'v' literally
  • \b Match a word boundary
  • [a-z&\'\(\) ]+ Match one or more of the characters in this group
  • (?: Begin non-capturing group
    • .*? Match anything
  • ) End non-capturing group
  • \[?\d+ \w+ \d{4}\]? Match a date, optionally surrounded by brackets
• ) End capture group

You might write a pattern matching [...] and then repeat 1 or more times a . and again [...]

\[[^][]*](?:\.\[[^][]*])+

Explanation

• \[[^][]*] Match from [...] using a negated character class
• (?: Non capture group to repeat as a whole part
  • \.\[[^][]*] Match a dot and again [...]
• )+ Close the non capture group and repeat 1+ times

See a regex demo.

To get multiple matches, you can use re.findall

import re

pattern = r"\[[^][]*](?:\.\[[^][]*])+"

s = ("CASE[Data Source].[Week] = 'THIS WEEK'\n"
            "CASE[Data Source].[Week] = 'THIS WEEK'")

print(re.findall(pattern, s))

Output

['[Data Source].[Week]', '[Data Source].[Week]']

If you also want the values of between square brackets when there is not dot, you can use an alternation with lookaround assertions:

\[[^][]*](?:\.\[[^][]*])+|(?<=\[)[^][]*(?=])

Explanation

• \[[^][]*](?:\.\[[^][]*])+ The same as the previous pattern
• | Or
• (?<=\[)[^][]*(?=]) Match [...] asserting [ to the left and ] to the right

See another regex demo

How about:

import re

s = "alpha.Customer[cus_Y4o9qMEZAugtnW] ..."
m = re.search(r"\[([A-Za-z0-9_]+)\]", s)
print m.group(1)

For me this prints:

cus_Y4o9qMEZAugtnW

Note that the call to re.search(...) finds the first match to the regular expression, so it doesn't find the [card] unless you repeat the search a second time.

Edit: The regular expression here is a python raw string literal, which basically means the backslashes are not treated as special characters and are passed through to the re.search() method unchanged. The parts of the regular expression are:

1. \[ matches a literal [ character
2. ( begins a new group
3. [A-Za-z0-9_] is a character set matching any letter (capital or lower case), digit or underscore
4. + matches the preceding element (the character set) one or more times.
5. ) ends the group
6. \] matches a literal ] character

Edit: As D K has pointed out, the regular expression could be simplified to:

m = re.search(r"\[(\w+)\]", s)

since the \w is a special sequence which means the same thing as [a-zA-Z0-9_] depending on the re.LOCALE and re.UNICODE settings.

use this regex expression (\[[,\d\s ]*)11([,\d\s ]*\]) for retrieving all the 11's in the text

have a look at the example I uploaded https://regex101.com/r/lN8mA6/1

Based on your shown samples, could you please try following.

import re
value='Example.[1]'
re.sub(r"\.\[\d+\]",'',value)

Explanation: Importing re library of python here. Then creating a sample variable named value which has Example.[1] in it. Now as per OP substituting .(DOT) [ followed by 1 or more occurrences of digits ] with NULL in value.

What you need is re.sub. Note that both square brackets and pipes are meta-characters so they need to be escaped.

re.sub(r'\[\[(?:[^\]|]*\|)?([^\]|]*)\]\]', r'\1', line)

The \1 in the replacement string refers to what was matched inside the parentheses, that do not start with ?: (i.e. in any case the text you want to have).

There are two caveats. This allows for only a single pipe between the opening and closing brackets. If there are more than one you would need to specify whether you want everything after the first or everything after the last one. The other caveat is that single ] between opening and closing brackets are not allowed. If that is a problem, there would still be a regex solution but it would be considerably more complicated.

For a full explanation of the pattern:

\[\[        # match two literal [
(?:         # start optional non-capturing subpattern for pre-| text
   [^\]|]   # this looks a bit confusing but it is a negated character class
            # allowing any character except for ] and |
   *        # zero or more of those
   \|       # a literal |
)?          # end of subpattern; make it optional
(           # start of capturing group 1 - the text you want to keep
    [^\]|]* # the same character class as above
)           # end of capturing group
\]\]        # match two literal ]

To expand on the explanation of the regex used by Avinash in his answer:

Category:([^\[\]]*) consists of several parts:

• Category: which matches the text "Category:"
• (...) is a capture group meaning roughly "the expression inside this group is a block that I want to extract"
• [^...] is a negated set which means "do not match any characters in this set".
• \[ and \] match "[" and "]" in the text respectively.
• * means "match zero or more of the preceding regex defined items"

Where I have used ... to indicate that I removed some characters that were not important for the explanation.

So putting it all together, the regex does this:

Finds "Category:" and then matches any number (including zero) characters after that that are not the excluded characters "[" or "]". When it hits an excluded character it stops and the text matched by the regex inside the (...) part is returned. So the regex does not actually look for "[[" or "]]" as you might expect and so will match even if they are left out. You could force it to look for the double square brackets at the beginning and end by changing it to \[\[Category:([^\[\]]*)\]\].

For the second regex, Category:[^\[\]]*, the capture group (...) is excluded, so Python returns everything matched which includes "Category:".

The \n newlines in your source string are the likely problem. In non dot all mode, .* cannot traverse over newlines. Try running your regex find all in dot all mode:

a = '\tvar mydata = [{\nZWeight:"13.00",\nStyleName:"FIRECREEK SOLID",\nColorName:"TRADITION"\n}\n]'
output = re.findall(r'var mydata = \[(.*?)\]', a, flags=re.S)
print(output)

# ['{\nZWeight:"13.00",\nStyleName:"FIRECREEK SOLID",\nColorName:"TRADITION"\n}\n']

You can match the following regular expression.

^(?P<timestamp>[JFMASOND][a-z]{2} [0123]\d [012]\d(?::[0-5]\d){2}\.\d{6}\b) (?P<levelname>[A-Z]) +(?:[A-Z]+: +)?(?:\[+(?P<source>[A-Za-z]+)\]+)? *(?P<message>.+)

Demo

Notice that I've made the capture group source optional.

Depending on requirements some adjustments may need to be made. I assumed, for example, that the source capture group would contain a single word and if there were non-spaces between the levelname and source (or message) it would be comprised of one or more capital letters followed by a colon, as in the second example ('ERR:'). I've also made assumptions about how rigorous the timestamp format must be specified and which capture groups should be made optional. These were of course just guesses about the specification as they were not spelled out in the question.

The regular expression can be broken down as follows. Note that I have put individual spaces in character classes ([ ]) merely to make them visible to the reader. I've tested this with Python (for which named character classes are written (?P<name>....), but it would work in Ruby as well.

^                     # match beginning of string

(?P<timestamp>        # begin 'timestamp' capture group
  [JFMASOND]          # match a cap letter in the char class
  [a-z]{2}            # match two lowercase letters
  [ ]                 # match a space
  [0123]\d            # match a digit in the char class then any digit
  [ ]                 # match a space
  [012]\d             # match a digit in the char class then any digit
  (?:                 # begin a non-capture group
    :                 # match a colon
    [0-5]\d           # match a digit in the char class then any digit 
  ){2}                # end non-capture group and execute it twice
  \.                  # match a period
  \d{6}               # match 6 digits
  \b                  # match a word boundary
)                     # end timestamp capture group

(?P<levelname>        # begin 'levelname' capture group
  [A-Z])[ ]+          # match a capital letter then >= 1 spaces
)                     # end 'levelname' capture group 

(?:[A-Z]+:[ ]+)?      # optionally match >= 1 capital letters
                      # then >= 1 spaces

(?:                   # begin non-capture group
  \[+                 # match one or more left brackets
  (?P<source>         # begin capture group 'source'
    [A-Za-z]+         # match >= 1 chars in char class
  )                   # end capture group 'source'
  \]+                 # match one or more right brackets
)?                    # end non-capture group and make optional

[ ]*                  # match >= 0 spaces

(?P<message>.+)       # match rest of line and save to capture
                      # group 'message'