python过滤器重写过滤器

工作代码

def not_double_cap_word(word):
    cap_count = 0
    for ch in word: 
        if str.isupper(ch):
            cap_count += 1
    not_double_cap = (cap_count < 2)
    return not_double_cap    
...

    words_no_double_caps =list(filter(not_double_cap_word,words_alnum))

def not_double_cap_单词（单词）：
上限计数=0
对于ch in word：
如果str.isupper（ch）：
上限计数+=1
非双上限=（上限计数<2）
不返回双盖
...
words\u no\u double\u caps=列表（过滤器（非double\u cap\u word，words\u alnum））

---

有什么不同的解决方案，比如说在Python中使用lambdas或其他模式？上面创建了一个新的单词列表，其中删除了两个以上大写字母的单词。一二二=>一二二。

你完全可以简化这个

函数，而不是double\u cap\u word

函数，但它仍然是相同的基本解决方案

首先，您可以使用

ch.isupper（）

而不是

str.isupper（ch）

。以常规方式调用方法总是比将其作为未绑定方法调用并显式传递

self

容易

接下来，我们可以在生成器表达式上用

sum

替换显式for循环：

cap_count = sum(ch.isupper() for ch in word)

而且我们实际上不需要定义

而不是double\u cap

，

cap\u count<2

似乎很简单，可以直接返回。因此：

def not_double_cap_word(word):
    cap_count = sum(ch.isupper() for ch in word)
    return cap_count < 2

（我想第二个版本中的parens是对的。如果不是……那么，如果我想用Lisp编程，我会。：）

不管怎样，它执行的步骤与原始代码几乎完全相同，但更简洁。它更具可读性吗？那由你决定。但这是选择其中一个或另一个，或介于两者之间的最重要的原因

---

好吧，那，以及你是否需要重用这个逻辑；如果你这样做了，它肯定应该用一个

def

语句来定义，并给它起个好名字。

你肯定可以简化

而不是double\u cap\u word

函数，但它仍然是相同的基本解决方案

首先，您可以使用

ch.isupper（）

而不是

str.isupper（ch）

。以常规方式调用方法总是比将其作为未绑定方法调用并显式传递

self

容易

接下来，我们可以在生成器表达式上用

sum

替换显式for循环：

cap_count = sum(ch.isupper() for ch in word)

而且我们实际上不需要定义

而不是double\u cap

，

cap\u count<2

似乎很简单，可以直接返回。因此：

def not_double_cap_word(word):
    cap_count = sum(ch.isupper() for ch in word)
    return cap_count < 2

（我想第二个版本中的parens是对的。如果不是……那么，如果我想用Lisp编程，我会。：）

不管怎样，它执行的步骤与原始代码几乎完全相同，但更简洁。它更具可读性吗？那由你决定。但这是选择其中一个或另一个，或介于两者之间的最重要的原因

---

好吧，那，以及你是否需要重用这个逻辑；如果你这样做了，它肯定应该用一个

def

语句来定义，并给它起个好名字。

你肯定可以简化

而不是double\u cap\u word

函数，但它仍然是相同的基本解决方案

首先，您可以使用

ch.isupper（）

而不是

str.isupper（ch）

。以常规方式调用方法总是比将其作为未绑定方法调用并显式传递

self

容易

接下来，我们可以在生成器表达式上用

sum

替换显式for循环：

cap_count = sum(ch.isupper() for ch in word)

而且我们实际上不需要定义

而不是double\u cap

，

cap\u count<2

似乎很简单，可以直接返回。因此：

def not_double_cap_word(word):
    cap_count = sum(ch.isupper() for ch in word)
    return cap_count < 2

（我想第二个版本中的parens是对的。如果不是……那么，如果我想用Lisp编程，我会。：）

不管怎样，它执行的步骤与原始代码几乎完全相同，但更简洁。它更具可读性吗？那由你决定。但这是选择其中一个或另一个，或介于两者之间的最重要的原因

---

好吧，那，以及你是否需要重用这个逻辑；如果你这样做了，它肯定应该用一个

def

语句来定义，并给它起个好名字。

你肯定可以简化

而不是double\u cap\u word

函数，但它仍然是相同的基本解决方案

首先，您可以使用

ch.isupper（）

而不是

str.isupper（ch）

。以常规方式调用方法总是比将其作为未绑定方法调用并显式传递

self

容易

接下来，我们可以在生成器表达式上用

sum

替换显式for循环：

cap_count = sum(ch.isupper() for ch in word)

而且我们实际上不需要定义

而不是double\u cap

，

cap\u count<2

似乎很简单，可以直接返回。因此：

def not_double_cap_word(word):
    cap_count = sum(ch.isupper() for ch in word)
    return cap_count < 2

（我想第二个版本中的parens是对的。如果不是……那么，如果我想用Lisp编程，我会。：）

不管怎样，它执行的步骤与原始代码几乎完全相同，但更简洁。它更具可读性吗？那由你决定。但这是选择其中一个或另一个，或介于两者之间的最重要的原因

---

好吧，那，以及你是否需要重用这个逻辑；如果您这样做，它肯定应该用一个

def

语句定义，并给它起一个好名字。

您可以使用

sum

重写您的

not double\u cap\u word

代码：

def not_double_cap_word(word):
    return sum(x.isupper() for x in word) < 2

---

您可以使用

sum

重写您的

not\u double\u cap\u word

代码：

def not_double_cap_word(word):
    return sum(x.isupper() for x in word) < 2

---

您可以使用

sum

重写您的

not\u double\u cap\u word

代码：

def not_double_cap_word(word):
    return sum(x.isupper() for x in word) < 2

---

您可以使用

sum

重写您的

not\u double\u cap\u word

代码：

def not_double_cap_word(word):
    return sum(x.isupper() for x in word) < 2

---

我不了解你的输出，

一两

如何变成

一、二

。你说的“使用lambdas”是什么意思<代码> lambda < /Cord>只是一种不同的编写相同类型函数的方法，<>代码> DEF给了你，一个不允许你使用语句或给函数命名的函数，但是允许你在表达式中间进行。你认为你为什么想要这个？我不了解你的输出，

一两