提取 .txt 文件中两个关键字之间的所有单词

Question

I would like to extract all words within specific keywords in a .txt file. For the keywords, there is a starting keyword of PROC SQL; (I need this to be case insensitive) and the ending keyword could be either RUN; , quit; or QUIT; . This is my sample .txt file .

Thus far, this is my code:

with open('lan sample text file1.txt') as file:
    text = file.read()
    regex = re.compile(r'(PROC SQL;|proc sql;(.*?)RUN;|quit;|QUIT;)')
    k = regex.findall(text)
    print(k)

Output:

[('quit;', ''), ('quit;', ''), ('PROC SQL;', '')]

However, my intended output is to get the words in between and inclusive of the keywords:

proc sql; ("TRUuuuth");
hhhjhfjs as fdsjfsj:
select * from djfkjd to jfkjs
(
SELECT abc AS abc1, abc_2_ AS efg, abc_fg, fkdkfj_vv, jjsflkl_ff, fjkdsf_jfkj
    FROM &xxx..xxx_xxx_xxE
where ((xxx(xx_ix as format 'xxxx-xx') gff &jfjfsj_jfjfj.) and 
      (xxx(xx_ix as format 'xxxx-xx') lec &jgjsd_vnv.))
 );

1)

jjjjjj;

  select xx("xE'", PUT(xx.xxxx.),"'") jdfjhf:jhfjj from xxxx_x_xx_L ;
quit; 

PROC SQL; ("CUuuiiiiuth");
hhhjhfjs as fdsjfsj:
select * from djfkjd to jfkjs
(SELECT abc AS abc1, abc_2_ AS efg, abc_fg, fkdkfj_vv, jjsflkl_ff, fjkdsf_jfkj
    FROM &xxx..xxx_xxx_xxE
where ((xxx(xx_ix as format 'xxxx-xx') gff &jfjfsj_jfjfj.) and 
      (xxx(xx_ix as format 'xxxx-xx') lec &jgjsd_vnv.))(( ))
 );

2)(

RUN;

Any advice or different ways to go about this would be greatly appreciated!

Output after implementing user @Finefoot's code:

However, is there a way to separate the lines to look something like this instead?:

Answer 1

This works for me:

import re

with open('lan sample text file1.txt') as file:
    condition = False
    text_to_return = ""
    for line in file:
        if condition == True:
            if line[0:5].lower() == "quit;" or line[0:4].upper() == "RUN;":
                condition = False    
            text_to_return += line
        if line[0:9].upper() == "PROC SQL;":
            condition = True
            text_to_return += line

    output_file = open("output.txt", "w")
    output_file.write(text_to_return)
    output_file.close()

Is this an acceptable solution to you?

Answer 2

A solution if you don't want to use Regular Expressions:

starts=["PROC SQL;"]
ends = ["RUN;", "RUN;", "QUIT;"]

with open('/tmp/some_file.txt') as f:
    content = f.read() 

    for s, e in zip(starts, ends):
        if s.lower() in content.lower() and e.lower() in content.lower():
            start = content.lower().find(s.lower())
            end = content.lower().find(e.lower()) + len(e)

            print(content[start:end])

Does it help you?

Answer 3

In your pattern (PROC SQL;|proc sql;(.*?)RUN;|quit;|QUIT;) is a typo, I think, as you're missing a closing parenthesis ) after proc sql; and before (.*?) as well as opening parenthesis ( afterwards. However, that's not all, you still won't get your desired result with the typo fixed.

Have a look at the Python docs for re :

. (Dot.) In the default mode, this matches any character except a newline. If the DOTALL flag has been specified, this matches any character including a newline.

As your input does contain newlines which you'd like . to match, you need to use the re.DOTALL flag. While we're on the topic of flags: you might also want to use the re.IGNORECASE flag if you really don't care about case sensitivity of your keywords.

Also, I guess you don't want your keywords like PROC SQL; in your result, so you can use (?:...) which is the non-capturing version of regular parentheses.

The final regex pattern:

re.findall(r"(?:PROC SQL;)(.*?)(?:RUN;|QUIT;)", text, flags=re.IGNORECASE|re.DOTALL)

---

Update:

In your update code in the Jupyter cell above, the results of re.findall are saved as variable regex . It's a list of strings, that match the pattern. If you call print(regex) you will print the list (which will show its elements, the strings, with \\n ). If you don't want \\n , you could print the elements (the strings themselves) instead: print(*regex) The default separator between two elements will be a simple space character, though, so you might want to set sep to something else like multiple newlines print(*regex, sep="\\n"*5) or a separating line of ----- like print(*regex, sep="\\n"+"-"*44+"\\n") . But that's something you'll have to decide which way will suit you best to present your results.

Also, if the pattern doesn't seem too confusing already, you might want to use "inline modifiers" instead of the flags argument. It's (?i:...) for case-insensitive matching and (?s:...) instead of the DOTALL flag:

re.findall(r"(?i:PROC SQL;)((?s:.*?))(?i:RUN;|QUIT;)", text)

Answer 4

You can get a more efficient match by matching the keywords and match all the lines that do not start with quit or RUN to prevent unnecessary backtracking caused by .*?

If you want the keywords included in the match, you can omit the capturing groups.

You could use the re.IGNORECASE flag to get a case insensitive match and use re.MULTILINE as the pattern contains an anchor asserting the start of the string.

^PROC SQL;.*\n(?:(?!RUN;|QUIT;).*\n)*(?:RUN|QUIT);

• ^ Start of line
• PROC SQL; Match literally
• .*\\n Match 0+ times any char except a newline, then match a newline (or use \\r?\\n
• (?: Non capturing group
  • (?!RUN;|QUIT;) Assert what is directly to the right is not RUN; or QUIT;
  • .*\\n Match 0+ times any char except a newline, then match a newline
• )* Close group and repeat 0+ times
• (?:RUN|QUIT); Match either RUN; or QUIT;

Regex demo | Python demo

For example

with open('lan sample text file1.txt') as file:
    text = file.read()
    regex = re.compile(r'^PROC SQL;.*\n(?:(?!RUN;|QUIT;).*\n)*(?:RUN|QUIT);', re.MULTILINE | re.IGNORECASE)
    k = regex.findall(text)
    print(k)