@aesh
我浏览了上面的几个答案，我意识到当一个简单的苍蝇拍就足够的时候，人们是多么快地带进一头大象来杀死一只老鼠。
下面是一个小的简洁和可折叠的脚本，同时试图保留动态的一面。

import re

text     = "My favorite languages are Python and Java. I like less Rust and Javascript and my Python is a little rusty"
keywords = ["C#", "JAVA", "PHP", "PYTHON", "JAVASCRIPT", "RUST"]

j = '|'.join(keywords)

r = re.compile(rf'\b({j})\b', re.IGNORECASE)
matches = r.findall(text)

d = dict()

for i, m in enumerate(matches):
    # if m not in d.values(): # To avoid duplicates, uncomment this line and indent the next one
    d["var_" + str(i)] = m   

for k, v in d.items():
    print(f'{k} = {v}')

打印出来

var_0 = Python
var_1 = Java
var_2 = Rust
var_3 = Javascript
var_4 = Python

我认为正则表达式是最好的方法。

import re

text     = "My favorite languages are Python and Java. I like less Rust. Python meh"
keywords = ["C#", "JAVA", "PHP", "PYTHON", "JAVASCRIPT"]

regex = re.compile(r'|'.join(keywords), re.IGNORECASE)
print(regex.findall(text))

输出：

['Python', 'Java', 'Python']

这将打印python两次，你没有指定这是否是期望的行为。

由于搜索的是完美匹配，我建议使用一个没有re的解决方案。虽然re是标准库-因此应该使用它。

class MyContainer:
    def __init__(self, keywords, ignore_case=True, remove_signs=True, return_key=False):
        self._keywords = keywords      # keep original input
        self.ignore_case = ignore_case
        self.remove_signs = remove_signs
        self.keywords = [self.prepare(x) for x in keywords]
        self.return_key = return_key
        self._keydict = {k: v for k, v in zip(self.keywords, self._keywords)}
    
    def __contains__(self, x):
        return self.prepare(x) in self.keywords
    
    def remove_sign(self, x):
        return x.rstrip("!.?;,- \t\"\'")
    
    def prepare(self, x):
        if self.ignore_case:
            x = x.lower()
        if self.remove_signs:
            x = self.remove_sign(x)
        return x
    
    def findall(self, s):
        return [x if not self.return_key else self._keydict[self.prepare(x)] for x in s.split() if x in self]

# return what was found in text
kws = MyContainer(keywords, ignore_case=True, remove_signs=True, return_key=False)
kws.findall(text) 
## ['Python', 'Java.', 'Python']

# return as given in keywords
kws = MyContainer(keywords, ignore_case=True, remove_signs=True, return_key=True)
kws.findall(text) 
## ['PYTHON', 'JAVA', 'PYTHON']

使用__init__方法，您可以根据ignore_case和remove_signs预先准备关键字列表。__contains__ dunder方法通过in运算符易于使用。
使用标志参数ignore_case，remove_signs，return_key，您可以确定是否应忽略大小写，删除右端的符号以及单词是否应分别在文本中找到或在关键字中指定。

对于你的var1，var2等问题，通过解构在Python中使用多重赋值：

var1, var2, var3 = matches

如果你想把它们打印出来：

for i, x in enumerate(matches):
    print(f"var{i} = {x}")

为了让我的解决方案尽可能与你的相似，我认为这是最好的方法（OFC不使用其他库）。

text     = "My favorite languages are Python and Java. I like less Rust."
keywords = ["C#", "JAVA", "PHP", "PYTHON", "JAVASCRIPT", "RUST"] 

# Normalize text with no "stops"
text = text.replace(".", "")

# Split Upper Text
text = text.upper().split()

# Iterate through Tw and if found in Kw append
matched = []
for w in text:
    for k in keywords:
        if w == k:
            matched.append(k)

var1, var2, var3 = matched
print(var1, var2, var3, sep="\n")

如果你想创建“动态变量”，我不认为你可以，你必须声明它们。出于这个原因，最好有一个列表，当你需要的时候，访问/迭代到你需要的值。
我希望对你有所帮助
编辑：可以动态赋值变量但不是“好用”

vars = [f"var{i} ='{v}'" for i,v in enumerate(matched)]
for e in vars:
    exec(e)

print(var1)

所以，我做了一些测试，我认为这将是最容易的工作：
text =“我最喜欢的语言是Python和Java。我不喜欢Rust”
keywords = [“C#"，“JAVA”，“PHP”，“PYTHON”，“JAVASCRIPT”，“RUST”]
matches = [x for x in keywords if x in text.upper（）]
对于匹配中的x：

print("test x: ", x) #Java, Python, Rust

print(x)

希望这有帮助！