blocks|key|3258754|text|不要给变量(包括参数)命名str，因为它会隐藏内置的str函数/类型！您可以使用str作为类型注释，但它应该在参数名称(如)的之后出现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|3258755|**kwargs的思想是让您的函数能够接受一组任意的关键字参数(而不是位置参数)。在函数的实现中，参数可以作为dict使用。|3258756|def+alliteration_check(**kwargs:+str)+->+bool:
++++for+s+in+kwargs.values():
++++++++w1,+w2+=+s.split()
++++++++if+w1[0].upper()+!=+w2[0].upper():
++++++++++++return+False
++++return+True|code-block|syntax|javascript|3258757|您需要使用关键字参数调用此函数，如下所示：|3258758|alliteration_check(thing1="zig+zag",+other_thing="awkward+alligator")|3258759|如果希望用户能够使用任意数量的位置参数(而不是关键字参数)调用函数，请使用*args|3258760|def+alliteration_check(*args:+str)+->+bool:
++++for+s+in+args:
++++++++w1,+w2+=+s.split()
++++++++if+w1[0].upper()+!=+w2[0].upper():
++++++++++++return+False
++++return+True|3258761|alliteration_check("zig+zag",+"awkward+alligator")|3258762|您还可以将两者结合在一起(即，具有一个同时使用*args和**kwargs的函数)，以便能够在以下两种语法中处理参数：|3258763|def+alliteration_check(*args:+str,+**kwargs:+str)+->+bool:
++++for+s+in+(*args,+*kwargs.values()):
++++++++w1,+w2+=+s.split()
++++++++if+w1[0].upper()+!=+w2[0].upper():
++++++++++++return+False
++++return+True|3258764|entityMap^0|D|3|Q|3|14|3|1P|2|0|0|8|1J|4|0|0|0|0|11|5|0|0|0|N|5|T|8|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|E|@]|F|$]]|$1|I|3|J|5|K|7|1H|8|@]|E|@]|F|$L|M]]|$1|N|3|O|5|6|7|1I|8|@]|E|@]|F|$]]|$1|P|3|Q|5|K|7|1J|8|@]|E|@]|F|$L|M]]|$1|R|3|S|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|E|@]|F|$]]|$1|T|3|U|5|K|7|1N|8|@]|E|@]|F|$L|M]]|$1|V|3|W|5|K|7|1O|8|@]|E|@]|F|$L|M]]|$1|X|3|Y|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|E|@]|F|$]]|$1|Z|3|10|5|K|7|1U|8|@]|E|@]|F|$L|M]]|$1|11|3|-4|5|6|7|1V|8|@]|E|@]|F|$]]]|12|$]]

Don't name a variable (including a parameter) <code>str</code>, because it'll shadow the builtin <code>str</code> function/type! You can use <code>str</code> as a type annotation, but it should come after the name of the parameter, eg <code>foo: str</code>.
The idea of <code>**kwargs</code> is for your function to be able to take an arbitrary set of keyword arguments (not position arguments). Inside the implementation of the function, the arguments are available as a <code>dict</code>.
<pre><code>def alliteration_check(**kwargs: str) -&gt; bool:
 for s in kwargs.values():
 w1, w2 = s.split()
 if w1[0].upper() != w2[0].upper():
 return False
 return True
</code></pre>
You need to call this function with keyword arguments, like this:
<pre><code>alliteration_check(thing1=&quot;zig zag&quot;, other_thing=&quot;awkward alligator&quot;)
</code></pre>
If you want the user to be able to call the function with an arbitrary number of positional arguments rather than keyword arguments, use <code>*args</code>:
<pre><code>def alliteration_check(*args: str) -&gt; bool:
 for s in args:
 w1, w2 = s.split()
 if w1[0].upper() != w2[0].upper():
 return False
 return True
</code></pre>
<pre><code>alliteration_check(&quot;zig zag&quot;, &quot;awkward alligator&quot;)
</code></pre>
You can also combine both of them (i.e. have a function that takes both <code>*args</code> and <code>**kwargs</code>) to be able to handle arguments in either syntax:
<pre><code>def alliteration_check(*args: str, **kwargs: str) -&gt; bool:
 for s in (*args, *kwargs.values()):
 w1, w2 = s.split()
 if w1[0].upper() != w2[0].upper():
 return False
 return True
</code></pre>

blocks|key|4096365|text|def+alliteration_check(*args):
++++initialWord+=+args[0]
++++allEqual=true
++++for+word+in+args:
+++++++if+(word+!=+initialWord):
+++++++++++allEqual=false
+++++++++++break
++++return+allEqual

alliteration_check("4",+"5")
alliteration_check("10",+"9")
alliteration_check('2',+"3",+"4")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4096366|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def alliteration_check(*args):
 initialWord = args[0]
 allEqual=true
 for word in args:
 if (word != initialWord):
 allEqual=false
 break
 return allEqual

alliteration_check(&quot;4&quot;, &quot;5&quot;)
alliteration_check(&quot;10&quot;, &quot;9&quot;)
alliteration_check('2', &quot;3&quot;, &quot;4&quot;)
</code></pre>

blocks|key|4096476|text|这是我找到的解决办法。对于您的具体情况，您应该使用*args而不是**kwargs|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4096477|def+alliteration_check(*args):
++++allit+=+True
++++for+arg+in+args:
++++++++if+arg[0].upper()+!=+args[(args.index(arg))-1][0].upper():
++++++++++++allit+=+False

++++return+allit|code-block|syntax|javascript|4096478|基本上，这会检查输入到前一个函数中的每个参数，并确保所有函数中的第一个字母是相同的。如果在任何一点上都不相等，它就会将Allit变量更改为false，并脱离循环。|4096479|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Here is the solution I got. For your specific situation you should be using *args not **kwargs
<pre><code>def alliteration_check(*args):
 allit = True
 for arg in args:
 if arg[0].upper() != args[(args.index(arg))-1][0].upper():
 allit = False

 return allit
</code></pre>
basically this checks every argument entered into the function to the previous one and makes sure that the first letter in all of those is the same. If at any point it is not equal it changes the allit variable to false and breaks out of the loop.

blocks|key|3258924|text|在您的例子中，使用*args+--一个非键的、可变长度的参数列表--可能更合适，因为您想检查可变的单词数。然后你可以像一个列表一样迭代这个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3258925|在您的情况下，您只想检查每个单词的第一个字母是相同的大小写-不敏感。我将构建一个集合，并检查它只包含一个元素：|3258926|def+alliteration_check(*args):
++++return+len(set(s[0].upper()+for+s+in+args))+==+1|code-block|syntax|javascript|3258927|你会像这样使用它：|3258928|print(alliteration_check("hello",+"Hello",+"hi"))|3258929|输出：|3258930|True|3258931|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

It might be more appropriate to use *args - a non-key worded, variable-length argument list - in your case because you want to check a variable number of words. Then you can iterate this like a list.
In your case you just want to check the first letter of each word is the same case-insensitive. I would build a set and check it only contains one element:
<pre><code>def alliteration_check(*args):
 return len(set(s[0].upper() for s in args)) == 1
</code></pre>
You would use it like this:
<pre><code>print(alliteration_check(&quot;hello&quot;, &quot;Hello&quot;, &quot;hi&quot;))
</code></pre>
Output:
<pre><code>True
</code></pre>

I've written a basic function that takes any two-word string passed as an argument, checks that the index of both words match and returns True, otherwise False.
<pre><code>def alliteration_check(str):

 sp1, sp2 = str.split()

 if sp1[0].upper() == sp2[0].upper():
 return True
 else:
 return False
</code></pre>
I wanted to know if it is possible to change the param of str here to take in **kwargs? I've only recently learned about this concept so trying to understand how I can put it into practice.
Essentially, my intended function output would be that a user can place as many words as an argument and it only returns True if ALL first indexes of each string match. I'm just not sure how to write the function or if it is even possible?
Thanks in advance!

Modifying A Two-Word String Function To Take **kwargs in Python?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我已经编写了一个基本函数，它使用作为参数传递的任何两个单词字符串，检查两个单词的索引是否匹配并返回True，否则为False。def alliteration_check(str):    sp1, sp2 = str.split()    if sp1[0].upper() == sp2[0].upper():   ...

问修改一个双字字符串函数，以便在Python中使用**kwargs？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问修改一个双字字符串函数，以便在Python中使用**kwargs？EN