blocks|key|309026|text|foo+=+5在函数中创建一个局部变量。def+foo创建一个全局变量。这就是为什么他们可以有相同的名字。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|309027|如果在foo函数中引用foo()，则引用局部变量。如果您引用该函数之外的foo，则指的是全局变量。|309028|因为它显然会给试图遵循代码的人造成混乱，所以您可能不应该这样做。|309029|entityMap^0|0|7|K|7|0|3|3|B|5|10|3|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|K|$]]

<code>foo = 5</code> creates a local variable inside your function. <code>def foo</code> creates a global variable. That's why they can both have the same name.
If you refer to <code>foo</code> inside your <code>foo()</code> function, you're referring to the local variable. If you refer to <code>foo</code> outside that function, you're referring to the global variable.
Since it evidently causes confusion for people trying to follow the code, you probably shouldn't do this.

blocks|key|309078|text|答案是肯定的。函数是Python中的一级对象。foo函数与foo变量之间没有根本区别。这两个都是对内存的引用，并且都有一个作用域，因此它们都等价于一个变量。如果您已经将foo定义为一个函数，并且没有在本地覆盖它，那么它将类似于一个全局变量(取自上层范围)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|309079|def+foo():
++print(foo)|code-block|syntax|javascript|309080|然后，如果用局部变量覆盖它，它将只在函数范围内定义一个局部变量：|309081|def+foo():
++foo+=+3
++print(foo)|309082|在Python中，每个引用(变量)都可以覆盖特定范围的生存期。你可以试试：|309083|def+foo():+pass
foo+=+3|309084|这将覆盖foo的值，现在它将指向3，而不是内存中的foo函数。|309085|entityMap^0|N|3|T|3|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|16|8|@]|D|@]|E|$]]|$1|U|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|V|$]]

The answer is yes.
Functions are first-class objects in Python. There is no fundamental difference between the <code>foo</code> function and the <code>foo</code> variable. Both of those are references to the memory and both have a scope, so they are both equivalent to a variable.
If you have defined foo as a function and then don't overwrite it locally, it will be like a global variable (taken from the upper-level scope):
<pre><code>def foo():
 print(foo)
</code></pre>
and then if you overwrite it with a local variable, it will just define a local variable within the function scope:
<pre><code>def foo():
 foo = 3
 print(foo)
</code></pre>
In Python, every reference (variable) can be overwritten for the life span of a particular scope. You can try:
<pre><code>def foo(): pass
foo = 3
</code></pre>
This will overwrite the value of the foo and it will point now to 3 instead of the function foo in the memory.

blocks|key|150767|text|这是因为每个foo都是变量的范围。函数foo()在全局范围内，因此可以在其他函数中调用，也可以在函数之外调用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|150768|然而，变量foo在本地范围内。这意味着它只存在于函数的内部，不能在函数之外调用或引用它。|150769|因此，每个不同的函数在被调用时都会创建自己的本地作用域，并且一旦作用域被破坏(函数结束)，就会忘记在其中创建的变量。|150770|全局变量可以在本地范围内访问，局部变量不能在全局范围内访问。|BOLD|150771|如果要在全局范围中创建变量，请按如下方式调用它：|150772|global+var|code-block|syntax|javascript|150773|下面是一个全球和本地范围的例子：|150774|var=1
def+foo1():
++var=3
foo1()
print(var)+#prints+1+because+the+"var"+in+foo1()+is+locally+assigned
def+foo2():
++global+var
++var=2
foo2()
print(var)+#prints+2+because+"var"+is+global|150775|因此，您的函数可以工作，因为它只在本地指定名称foo，而不是全局分配。|150776|但是，如果您稍后在该函数中调用foo()，它将引发一个错误，因为这个本地作用域为foo分配了一个int值，而不是一个函数，因此不能调用。|150777|entityMap^0|6|3|J|5|0|5|3|0|0|J|A|0|0|0|0|0|N|3|0|0|2|F|5|14|3|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|1C|8|@$9|1D|A|1E|B|L]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1F|8|@]|D|@]|E|$]]|$1|O|3|P|5|Q|7|1G|8|@]|D|@]|E|$R|S]]|$1|T|3|U|5|6|7|1H|8|@]|D|@]|E|$]]|$1|V|3|W|5|Q|7|1I|8|@]|D|@]|E|$R|S]]|$1|X|3|Y|5|6|7|1J|8|@$9|1K|A|1L|B|C]]|D|@]|E|$]]|$1|Z|3|10|5|6|7|1M|8|@$9|1N|A|1O|B|L]|$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|11|3|-4|5|6|7|1T|8|@]|D|@]|E|$]]]|12|$]]

Well, it is because of the scope of variable each <code>foo</code> is. The function <code>foo()</code> is in the global scope, therefore can be called within other functions and outside of functions.
The variable <code>foo</code> however, is in the local scope. That means it only &quot;exists&quot; inside of the function, it cannot be called or referenced outside of the function.
So, each different function creates its own local scope when it is called, and the variables created within are forgotten as soon as the scope is destroyed (the function ends).
Global variables can be accessed within local scope, local variables cannot be accessed in global scope.
If you want to create the variable in the global scope, call it like this:
<pre class="lang-py prettyprint-override"><code>global var
</code></pre>
Here is an example of global and local scope:
<pre class="lang-py prettyprint-override"><code>var=1
def foo1():
 var=3
foo1()
print(var) #prints 1 because the &quot;var&quot; in foo1() is locally assigned
def foo2():
 global var
 var=2
foo2()
print(var) #prints 2 because &quot;var&quot; is global
</code></pre>
So, your function works because it i only assigning the name <code>foo</code> locally, not globally.
However, if you call <code>foo()</code> later in that function, it will raise an error because that local scope has assigned an int value to <code>foo</code>, not a function, therefore is not callable.

blocks|key|309163|text|其他人还没有提到:+Python是一种动态语言，很少进行静态检查。所以当你写|type|unstyled|depth|inlineStyleRanges|entityRanges|data|309164|def+foo():
++++foo+=+5
++++print(foo+%2B+5)|code-block|syntax|javascript|309165|你可能一直认为这是一个“矛盾”--+foo怎么能同时成为一个函数和一个整数变量？一阶答案是“这是两个不同的foo”，因为内部foo只是一个局部变量，与全局名称foo无关。但是让它成为全球性的，并且代码仍然有效！|offset|length|style|CODE|309166|def+foo():
++++global+foo
++++foo+=+5
++++print(foo+%2B+5)

foo()++#+OK,+prints+10|309167|在这段代码中只有一个foo！然而，它不是“一个变量和一个函数”。首先，在第1-4行中，我们将foo定义为一个具有特定主体的函数，但我们尚未执行该主体。在第4行之后，全局foo包含一个函数。然后，在第6行中，我们实际上调用了foo引用的函数，它执行它的主体。身体做的第一件事就是把5分配给foo.现在，foo持有一个整数。通过运行为foo分配一个新值的代码，我们改变了foo的值。它以前是那个函数，现在是5。在像Python这样的动态类型语言中，这没有什么问题。|309168|def+foo():
++++global+foo
++++foo+=+5
++++print(foo+%2B+5)

foo()++#+OK,+prints+10+(and+incidentally+assigns+a+new+value+to+foo)
foo()++#+Raises+TypeError:+'int'+object+is+not+callable|309169|entityMap^0|0|0|I|3|1H|3|1Q|3|27|3|0|0|A|3|1A|3|2C|3|33|3|3V|1|3Z|3|46|3|4L|3|53|3|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|16|8|@$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]|$I|1J|J|1K|K|L]|$I|1L|J|1M|K|L]|$I|1N|J|1O|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1P|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|T|$]]

Something nobody else has mentioned yet: Python is a dynamic language, with very little static checking. So when you write
<pre><code>def foo():
 foo = 5
 print(foo + 5)
</code></pre>
you might have been thinking of that as a &quot;contradiction&quot; — how can <code>foo</code> be a function and an integer variable at the same time? The first-order answer is &quot;It's two different <code>foo</code>s,&quot; because the inner <code>foo</code> is just a local variable, unrelated to the global name <code>foo</code>. But make it global, and the code still works!
<pre><code>def foo():
 global foo
 foo = 5
 print(foo + 5)

foo() # OK, prints 10
</code></pre>
In this code there is only one <code>foo</code>! However, it is not &quot;both a variable and a function.&quot; First, on lines 1–4, we define <code>foo</code> as a function with a certain body — but we do not execute that body yet. After line 4, the global <code>foo</code> holds a function. Then, on line 6, we actually call the function referred to by <code>foo</code>, which executes its body. The first thing the body does is assign <code>5</code> to <code>foo</code>... and now <code>foo</code> holds an integer. By running code that assigns a new value to <code>foo</code>, we've changed <code>foo</code>'s value. It used to be that-function-there; now it's 5. In a dynamically typed language like Python, there's nothing wrong with this.
<pre><code>def foo():
 global foo
 foo = 5
 print(foo + 5)

foo() # OK, prints 10 (and incidentally assigns a new value to foo)
foo() # Raises TypeError: 'int' object is not callable
</code></pre>

blocks|key|309197|text|使用同名的另一个问题显然是编写递归时的模糊性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|309198|def+fibo(n:+int)+->+int:
++++if+n+<=+1:
++++++++fibo+=+1
++++else:
++++++++fibo+=+fibo(n+-+1)+%2B+fibo(n+-+2)
++++return+fibo|code-block|syntax|javascript|309199|在以下方面的成果：|309200|UnboundLocalError:赋值前引用的局部变量fibo|blockquote|309201|之所以发生这种情况，是因为在函数中定义fibo时。当Python试图运行fibo(n+-+1)时，它会搜索本地fibo变量，并无法找到它的值。|offset|length|style|CODE|309202|entityMap^0|0|0|0|0|J|4|10|B|1J|4|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|V|8|@]|9|@]|A|$]]|$1|I|3|J|5|K|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@$N|Y|O|Z|P|Q]|$N|10|O|11|P|Q]|$N|12|O|13|P|Q]]|9|@]|A|$]]|$1|R|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|S|$]]

Another problem with using the same name is obviously the ambiguity when writing recursions:
<pre><code>def fibo(n: int) -&gt; int:
 if n &lt;= 1:
 fibo = 1
 else:
 fibo = fibo(n - 1) + fibo(n - 2)
 return fibo
</code></pre>
Results in:
<blockquote>
UnboundLocalError: local variable 'fibo' referenced before assignment
</blockquote>
It happens because when <code>fibo</code> is defined inside the function.
When Python tries to run <code>fibo(n - 1)</code> it searches the local <code>fibo</code> variable, and fails to find its value.

blocks|key|309204|text|只是一个简短的评论:+pylint用警告来标记这件事。皮林特是我们的朋友！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|309205|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Just a short remark: pylint marks this with a warning. pylint is our friend!

blocks|key|295347|text|在python中，变量的作用域是通过从当前最内部范围搜索到全局范围来确定的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|295348|Python+Scopes和命名空间(重点地雷)|blockquote|offset|length|295349|名称空间是从名称到对象的映射。|unordered-list-item|style|BOLD|295350|作用域是可直接访问名称空间的Python程序的文本区域。这里的“直接访问”意味着对名称的非限定引用试图在名称空间中找到名称。|295351|在执行过程中的任何时候，都有3个或4个嵌套作用域，其名称空间可以直接访问：|295352|首先搜索的最内部作用域包含本地名称。|ordered-list-item|295353|从最近的封闭范围开始搜索的任何封闭函数的作用域()都包含非本地的，但也包含非全局的名称。|295354|下一个作用域包含当前模块的全局名称。|295355|最外层作用域(最后搜索)是包含内置名称的命名空间。|295356|Python的一个特殊特点是--如果没有有效的全局或非局部语句--名称的分配总是进入最内部的范围。|295357|在这个例子中，|295358|#+Current+module's+scope+starts+here.

def+foo():
++++#+Local+Scope+Starts+here.
++++foo+=+5
++++print(foo+%2B+5)
++++#+Local+scope+Ends+here.

foo()

#+Current+module's+scope+ends+here.|code-block|syntax|javascript|295359|应用上述规则解决|295360|foo+=+5属于本地作用域，因为没有global或nonlocal语句。函数内部的foo属于函数的局部范围。|CODE|295361|当python开始从最内部的范围进行搜索时，print(foo+%2B+5)解析到函数中的foo。适用范围解决规则1和2。这里最内部的作用域与封闭函数的作用域相同。|295362|foo()在模块级作用域被调用.Python开始搜索最内部可用的范围，这里是模块级别。因此，它解析为在模块级别定义的函数。|295363|另一个例子，|295364|def+foo():
++++print(foo+%2B+5)

foo()
#+TypeError:+unsupported+operand+type(s)+for+%2B:+'function'+and+'int'|295365|295366|print(foo+%2B+5)还将解析为模块级的foo函数，因为python在封闭函数范围内启动搜索，但没有找到匹配项。移到下一个作用域，即模块级别，并找到一个匹配的。匹配是foo函数。因此，错误。|295367|295368|def+foo():
++++foo+=+"str"
++++def+inner():
#(1)++++foo+=+1+#+Commented+this+line
++++++++print(foo)
++++inner()
++++print(foo)

foo()
#+str
#+str

#+Uncommenting+(1)+gives+output+as

foo()
#+1
#+str|295369|阅读更多关于范围规则的信息|295370|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/tutorial/classes.html#python-scopes-and-namespaces|1|https://docs.python.org/3/reference/simple_stmts.html#global|2|https://docs.python.org/3/reference/simple_stmts.html#nonlocal|3|https://stackoverflow.com/q/291978^0|0|0|I|0|0|0|4|0|0|3|0|0|5|6|0|K|4|0|0|6|0|0|6|F|4|0|N|2|1|Q|3|2|0|0|0|0|0|7|J|6|Q|8|16|3|0|M|E|17|3|0|0|5|0|0|0|0|5|0|0|E|N|3|2E|3|0|0|0|6|4|3|0^^$0|@$1|2|3|4|5|6|7|26|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|27|8|@]|9|@$E|28|F|29|1|2A]]|A|$]]|$1|G|3|H|5|I|7|2B|8|@$E|2C|F|2D|J|K]]|9|@]|A|$]]|$1|L|3|M|5|I|7|2E|8|@$E|2F|F|2G|J|K]]|9|@]|A|$]]|$1|N|3|O|5|6|7|2H|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|2I|8|@$E|2J|F|2K|J|K]]|9|@]|A|$]]|$1|S|3|T|5|R|7|2L|8|@$E|2M|F|2N|J|K]]|9|@]|A|$]]|$1|U|3|V|5|R|7|2O|8|@$E|2P|F|2Q|J|K]]|9|@]|A|$]]|$1|W|3|X|5|R|7|2R|8|@$E|2S|F|2T|J|K]|$E|2U|F|2V|J|K]]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2W|8|@]|9|@$E|2X|F|2Y|1|2Z]|$E|30|F|31|1|32]]|A|$]]|$1|10|3|11|5|6|7|33|8|@]|9|@]|A|$]]|$1|12|3|13|5|14|7|34|8|@]|9|@]|A|$15|16]]|$1|17|3|18|5|6|7|35|8|@]|9|@]|A|$]]|$1|19|3|1A|5|I|7|36|8|@$E|37|F|38|J|1B]|$E|39|F|3A|J|1B]|$E|3B|F|3C|J|1B]|$E|3D|F|3E|J|1B]]|9|@]|A|$]]|$1|1C|3|1D|5|I|7|3F|8|@$E|3G|F|3H|J|1B]|$E|3I|F|3J|J|1B]]|9|@]|A|$]]|$1|1E|3|1F|5|I|7|3K|8|@$E|3L|F|3M|J|1B]]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|3N|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|14|7|3O|8|@]|9|@]|A|$15|16]]|$1|1K|3|1F|5|I|7|3P|8|@$E|3Q|F|3R|J|1B]]|9|@]|A|$]]|$1|1L|3|1M|5|I|7|3S|8|@$E|3T|F|3U|J|1B]|$E|3V|F|3W|J|1B]|$E|3X|F|3Y|J|1B]]|9|@]|A|$]]|$1|1N|3|1H|5|6|7|3Z|8|@]|9|@]|A|$]]|$1|1O|3|1P|5|14|7|40|8|@]|9|@]|A|$15|16]]|$1|1Q|3|1R|5|6|7|41|8|@]|9|@$E|42|F|43|1|44]]|A|$]]|$1|1S|3|-4|5|6|7|45|8|@]|9|@]|A|$]]]|1T|$1U|$5|1V|1W|1X|A|$1Y|1Z]]|20|$5|1V|1W|1X|A|$1Y|21]]|22|$5|1V|1W|1X|A|$1Y|23]]|24|$5|1V|1W|1X|A|$1Y|25]]]]

In python variable's scope is determined by searching from the current innermost scope to the global scope.
<blockquote>
<h2><a href="https://docs.python.org/3/tutorial/classes.html#python-scopes-and-namespaces" rel="nofollow noreferrer">Python Scopes and Namespaces</a>(Emphasis mine)</h2>
<ul>
<li>A namespace is a mapping from names to objects.</li>
<li>A scope is a textual region of a Python program where a namespace is directly accessible. “Directly accessible” here means
that an unqualified reference to a name attempts to find the name in
the namespace.</li>
</ul>
At any time during execution, there are 3 or 4 nested scopes whose
namespaces are directly accessible:
<ol>
<li>the innermost scope, which is searched first, contains the local names</li>
<li>the scopes of any enclosing functions, which are searched starting with the nearest enclosing scope, contains non-local, but also
non-global names</li>
<li>the next-to-last scope contains the current module’s global names</li>
<li>the outermost scope (searched last) is the namespace containing built-in names.</li>
</ol>
A special quirk of Python is that – if no
<a href="https://docs.python.org/3/reference/simple_stmts.html#global" rel="nofollow noreferrer">global</a>
or
<a href="https://docs.python.org/3/reference/simple_stmts.html#nonlocal" rel="nofollow noreferrer">nonlocal</a>
statement is in effect – assignments to names always go into the
innermost scope.
</blockquote>
In the example,
<pre class="lang-py prettyprint-override"><code># Current module's scope starts here.

def foo():
 # Local Scope Starts here.
 foo = 5
 print(foo + 5)
 # Local scope Ends here.

foo()

# Current module's scope ends here.
</code></pre>
Applying the above rules to resolve the scope of
<ul>
<li><code>foo = 5</code> belongs to local scope as there's no <code>global</code> or <code>nonlocal</code> statement. <code>foo</code> which is inside the function belongs to the local scope of the function.
</li>
<li><code>print(foo + 5)</code> resolve to the <code>foo</code> present inside the function as python starts searching from the innermost scope. Scope resolution rules 1 and 2 apply. The innermost scope here is the same as the scope of enclosing function.
</li>
<li><code>foo()</code> is called at the module-level scope. Python starts searching the innermost scope available which here is module-level. Hence, it resolved to the function defined at the module level.
</li>
</ul>
Another example,
<pre class="lang-py prettyprint-override"><code>def foo():
 print(foo + 5)

foo()
# TypeError: unsupported operand type(s) for +: 'function' and 'int'
</code></pre>
<ul>
<li><code>foo()</code> is called at the module-level scope. Python starts searching the innermost scope available which here is module-level. Hence, it resolved to the function defined at the module level.</li>
<li><code>print(foo + 5)</code> would also resolve to module-level <code>foo</code> function because python starts the search in the enclosing function scope but found no match. Moved to next scope i.e module-level and found a match. The match is <code>foo</code> function. Hence, the error.</li>
</ul>
Another example,
<pre><code>def foo():
 foo = &quot;str&quot;
 def inner():
#(1) foo = 1 # Commented this line
 print(foo)
 inner()
 print(foo)

foo()
# str
# str

# Uncommenting (1) gives output as

foo()
# 1
# str
</code></pre>
Read more about <a href="https://stackoverflow.com/q/291978">Scoping rules</a>

Here's an example of what I mean:
<pre class="lang-py prettyprint-override"><code>def foo():
 foo = 5
 print(foo + 5)

foo()
# =&gt; 10
</code></pre>
The code doesn't produce any errors and runs perfectly. This contradicts the idea that variables and functions shouldn't have the same name unless you overwrite them. Why does it work? And when applied to real code, should I use different function/local variable names, or is this perfectly fine?

Can a function and local variable have the same name?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

下面是我的一个例子：def foo():    foo = 5    print(foo + 5)foo()# => 10该代码不会产生任何错误并完美地运行。这与这样的观点相矛盾，即变量和函数不应该有相同的名称，除非重写它们。为什么要工作？，当应用于实际代码时，我应该使用不同的函数/局部变量名，还是完全正确？

问函数和局部变量可以有相同的名称吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问函数和局部变量可以有相同的名称吗？EN