blocks|key|792653|text|在Python中，范围划分分为三种类型:全局、本地和类。您可以创建专门的“作用域”字典，以传递给exec+/+eval()。此外，还可以使用嵌套作用域(在另一个作用域中定义函数)。我发现这些在我所有的代码中都足够了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792654|正如Douglas已经说过的，在其他语言中使用它的主要原因是变量作用域，而这在Python中并不真正发生。此外，Python是我使用过的最易读的语言。这样做会有悖于可读性，比如“如果是真的”(你说你想要避免的)。在这种情况下，我认为最好的选择是将代码重构为多个函数，或者使用单个作用域。我认为Python中的可用作用域足以涵盖所有可能发生的情况，因此不应该真的需要本地范围。|792655|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In Python, scoping is of three types : global, local and class. You can create specialized 'scope' dictionaries to pass to exec / eval(). In addition you can use nested scopes
(defining a function within another). I found these to be sufficient in all my code.
As Douglas Leeder said already, the main reason to use it in other languages is variable scoping and that doesn't really happen in Python. In addition, Python is the most readable language I have ever used. It would go against the grain of readability to do something like if-true tricks (Which you say you want to avoid). In that case, I think the best bet is to refactor your code into multiple functions, or use a single scope. I think that the available scopes in Python are sufficient to cover every eventuality, so local scoping shouldn't really be necessary.

blocks|key|516781|text|为什么要在python中创建新的作用域呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|516782|在其他语言中这样做的正常原因是变量作用域，但在python中不发生这种情况。|516783|if+True:
++++a+=+10

print+a|code-block|syntax|javascript|516784|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Why do you want to create new scopes in python anyway?

The normal reason for doing it in other languages is variable scoping, but that doesn't happen in python.

<pre><code>if True:
 a = 10

print a
</code></pre>

blocks|key|2048414|text|如果您只想创建临时变量并让它们在使用后立即被垃圾收集，则可以使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2048415|del+varname|code-block|syntax|javascript|2048416|当你不再想要他们的时候。|2048417|如果只是为了美观，您可以使用注释或额外的换行符，但不需要额外的缩进。|2048418|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If you just want to create temp variables and let them be garbage collected right after using them, you can use

<pre><code>del varname
</code></pre>

when you don't want them anymore. 

If its just for aesthetics, you could use comments or extra newlines, no extra indentation, though.

blocks|key|792711|text|Python有两个作用域，一个是本地的，一个是全局的。函数中使用的变量无论是在什么缩进级别上创建，都在本地范围内。调用嵌套函数将产生您正在寻找的效果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792712|def+foo():
++a+=+1

++def+bar():
++++b+=+2
++++print+a,+b+#will+print+"1+2"

++bar()|code-block|syntax|javascript|792713|和其他人一样，我还要问你为什么要在一个函数中创建一个有限的作用域。|792714|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|$]]

Python has exactly two scopes, local and global. Variables that are used in a function are in local scope no matter what indentation level they were created at. Calling a nested function will have the effect that you're looking for.

<pre><code>def foo():
 a = 1

 def bar():
 b = 2
 print a, b #will print "1 2"

 bar()
</code></pre>

Still like everyone else, I have to ask you why you want to create a limited scope inside a function.

blocks|key|792590|text|列表理解中的变量(Python+)和生成器是本地的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792591|>>>+i+=+0
>>>+[i%2B1+for+i+in+range(10)]
[1,+2,+3,+4,+5,+6,+7,+8,+9,+10]
>>>+i
0|code-block|syntax|javascript|792592|但你到底为什么需要这个？|792593|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|$]]

variables in list comprehension (Python 3+) and generators are local:

<pre><code>&gt;&gt;&gt; i = 0
&gt;&gt;&gt; [i+1 for i in range(10)]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
&gt;&gt;&gt; i
0
</code></pre>

but why exactly do you need this?

blocks|key|792990|text|范围是Python程序的文本区域，其中可以直接访问名称空间。这里的“直接访问”意味着对名称的不限定引用试图在名称空间中找到名称.|type|blockquote|depth|inlineStyleRanges|entityRanges|data|792991|请阅读文献资料并澄清你的问题。|unstyled|offset|length|792992|顺便说一下，在C中不需要if(TRUE){}，一个简单的{}就足够了。|style|CODE|792993|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/tutorial/classes.html#python-scopes-and-name-spaces^0|0|3|4|0|0|C|A|S|2|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@$E|U|F|V|1|W]]|A|$]]|$1|G|3|H|5|D|7|X|8|@$E|Y|F|Z|I|J]|$E|10|F|11|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|D|7|12|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

<blockquote>
 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...
</blockquote>

Please, read <a href="http://docs.python.org/tutorial/classes.html#python-scopes-and-name-spaces" rel="nofollow noreferrer">the documentation</a> and clarify your question.

btw, you don't need <code>if(TRUE){}</code> in C, a simple <code>{}</code> is sufficient.

blocks|key|2048563|text|正如在其他答案中提到的，Python中没有类似于用块创建新范围的功能，但是在编写脚本或朱庇特笔记本时，我经常(Ab)使用类来引入新的名称空间，以达到类似的效果。例如，在笔记本中，您可能有一个模型"Foo“、"Bar”等以及相关变量，您可能希望创建一个新的范围，以避免重复使用类似的名称|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2048564|model+=+FooModel()
optimizer+=+FooOptimizer()
...
model+=+BarModel()
optimizer+=+BarOptimizer()|code-block|syntax|javascript|2048565|或后缀名称，如|2048566|model_foo+=+...
optimizer_foo+=+...

model_bar+=+...
optimizer_bar=+...|2048567|相反，您可以使用|2048568|class+Foo:
++++model+=+...
++++optimizer+=+...
++++loss+=+....

class+Bar:
++++model+=+...
++++optimizer+=+...
++++loss+=+...|2048569|然后访问变量，如|2048570|Foo.model
Bar.optimizer
...|2048571|我发现以这种方式使用名称空间创建新的作用域可以提高代码的可读性，减少错误的发生。|2048572|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

As mentioned in the other answers, there is no analogous functionality in Python to creating a new scope with a block, but when writing a script or a Jupyter Notebook, I often (ab)use classes to introduce new namespaces for similar effect. For example, in a notebook where you might have a model "Foo", "Bar" etc. and related variables you might want to create a new scope to avoid having to reuse names like

<pre><code>model = FooModel()
optimizer = FooOptimizer()
...
model = BarModel()
optimizer = BarOptimizer()
</code></pre>

or suffix names like

<pre><code>model_foo = ...
optimizer_foo = ...

model_bar = ...
optimizer_bar= ...
</code></pre>

Instead you can introduce new namespaces with

<pre><code>class Foo:
 model = ...
 optimizer = ...
 loss = ....

class Bar:
 model = ...
 optimizer = ...
 loss = ...
</code></pre>

and then access the variables as

<pre><code>Foo.model
Bar.optimizer
...
</code></pre>

I find that using namespaces this way to create new scopes makes code more readable and less error-prone.

blocks|key|792600|text|我认为这是一个明确的信号，表明是时候创建一个新函数并重构代码了。我看不出有什么理由创建这样一个新的范围。有什么理由吗？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|792601|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|$]]

I would see this as a clear sign that it's time to create a new function and refactor the code. I can see no reason to create a new scope like that. Any reason in mind?

blocks|key|2048270|text|def+a():
++++def+b():
++++++++pass
++++b()|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|2048271|如果我只想要一些额外的缩进或正在调试，我将使用if+True:|unstyled|offset|length|style|CODE|2048272|entityMap^0|0|N|8|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@$G|O|H|P|I|J]]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>def a():
 def b():
 pass
 b()
</code></pre>

If I just want some extra indentation or am debugging, I'll use <code>if True:</code>

blocks|key|517212|text|就像这样，对于任意名称t|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|517213|###+at+top+of+function+/+script+/+outer+scope+(maybe+just+big+jupyter+cell)
try:+t
except+NameError:
++++class+t
++++++++pass
else:
++++raise+NameError('please+`del+t`+first')

####+Cut+here+--+you+only+need+1x+of+the+above+--+example+usage+below+###

t.tempone+=+5+#+make+new+temporary+variable+that+definitely+doesn't+bother+anything+else.
#+block+of+calls+here...
t.temptwo+=+'bar'+#+another+one...
del+t.tempone+#+you+can+have+overlapping+scopes+this+way

#+more+calls
t.tempthree+=+t.temptwo;+del+t.temptwo+#+done+with+that+now+too
print(t.tempthree)
#+etc,+etc+--+any+number+of+variables+will+fit+into+t.


###+At+end+of+outer+scope,+to+return+`t`+to+being+'unused'
del+t|code-block|syntax|javascript|517214|所有这些都可以是函数def，也可以是脚本之外的任何位置。|517215|您可以在任何时候向任意命名的类添加或建模新元素。你真的只需要其中之一--然后根据你的意愿管理你的“临时”命名空间。|517216|如果它位于函数体中，则不需要del+t语句，但是如果包含它，则可以复制/粘贴代码块，并使它们按照您的预期工作(t‘的不同用法完全独立，每个用法从那个try:+t...块开始，以del+t结尾)。|517217|这样，如果t已经被用作变量，您就会知道，而且它不会让您知道它是什么。|517218|这不太容易出错，然后使用一系列random=named函数只调用它们一次--因为它避免了处理它们的名称，或者在定义它们之后记住调用它们，特别是当您不得不重新排序长代码时。|517219|这基本上就是你想要做的事情:做个临时的地方，把你知道的东西放进去，肯定不会与任何东西发生冲突，你要负责清理内部的东西。|517220|是的，它很难看，而且可能是不鼓励的--你将被引导将你的工作分解成一组更小、更可重用的函数。|517221|entityMap^0|B|1|0|0|0|0|E|5|22|9|2G|5|0|5|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|15|8|@]|D|@]|E|$]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1D|8|@$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1G|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1H|8|@]|D|@]|E|$]]|$1|W|3|X|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|Z|$]]

Like so, for arbitrary name <code>t</code>:

<pre><code>### at top of function / script / outer scope (maybe just big jupyter cell)
try: t
except NameError:
 class t
 pass
else:
 raise NameError('please `del t` first')

#### Cut here -- you only need 1x of the above -- example usage below ###

t.tempone = 5 # make new temporary variable that definitely doesn't bother anything else.
# block of calls here...
t.temptwo = 'bar' # another one...
del t.tempone # you can have overlapping scopes this way

# more calls
t.tempthree = t.temptwo; del t.temptwo # done with that now too
print(t.tempthree)
# etc, etc -- any number of variables will fit into t.


### At end of outer scope, to return `t` to being 'unused'
del t
</code></pre>

All the above could be in a function def, or just anyplace outside defs along a script. 

You can add or del new elements to an arbitrary-named class like that at any point. You really only need one of these -- then manage your 'temporary' namespace as you like.

The <code>del t</code> statement isn't necessary if this is in a function body, but if you include it, then you can copy/paste chunks of code far apart from each other and have them work how you expect (with different uses of 't' being entirely separate, each use starting with the that <code>try: t...</code> block, and ending with <code>del t</code>).

This way if <code>t</code> had been used as a variable already, you'll find out, and it doesn't clobber t so you can find out what it was. 

This is less error prone then using a series of random=named functions just to call them once -- since it avoids having to deal with their names, or remembering to call them after their definition, especially if you have to reorder long code.

This basically does exactly what you want: Make a temporary place to put things you know for sure won't collide with anything else, and which you are responsible for cleaning up inside as you go.

Yes, it's ugly, and probably discouraged -- you will be directed to decompose your work into a set of smaller, more reusable functions.

blocks|key|793043|text|正如其他人所建议的那样，python在不污染封闭命名空间的情况下执行代码的方法是将其放入类或函数中。这带来了一个轻微且通常无害的问题:定义函数时将其名称放在封闭的命名空间中。如果这对您造成损害，可以使用Python的常规临时变量“_”命名函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|793044|def+_():
++++polluting_variable+=+foo()
++++...
_()+#+Run+the+code+before+something+overwrites+the+variable.|code-block|syntax|javascript|793045|这可以递归地完成，因为每个本地定义都隐藏了封闭作用域中的定义。|793046|只有在非常特殊的情况下才需要这类东西。一个有用的例子是使用Databricks的%25run魔术，它在当前笔记本的全局范围内执行另一个笔记本的内容。将子笔记本的命令包装在临时函数中，防止它们污染全局命名空间。|offset|length|style|CODE|793047|entityMap^0|0|0|0|14|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

As others have suggested, the python way to execute code without polluting the enclosing namespace is to put it in a class or function. This presents a slight and usually harmless problem: defining the function puts its name in the enclosing namespace. If this causes harm to you, you can name your function using Python's conventional temporary variable "_":

<pre><code>def _():
 polluting_variable = foo()
 ...
_() # Run the code before something overwrites the variable.
</code></pre>

This can be done recursively as each local definition masks the definition from the enclosing scope.

This sort of thing should only be needed in very specific circumstances. An example where it is useful is when using Databricks' <code>%run</code> magic, which executes the contents of another notebook in the current notebook's global scope. Wrapping the child notebook's commands in temporary functions prevents them from polluting the global namespace.

In many languages (and places) there is a nice practice of creating local scopes by creating a block like <a href="https://stackoverflow.com/questions/541705/is-iftrue-a-good-idea-in-c">this</a>.

<pre><code>void foo()
{
 ... Do some stuff ...

 if(TRUE)
 {
 char a;
 int b;

 ... Do some more stuff ...
 }

 ... Do even more stuff ...
 }
</code></pre>

How can I implement this in python without getting the unexpected indent error and without using some sort of <a href="https://stackoverflow.com/questions/541705/is-iftrue-a-good-idea-in-c">if True:</a> tricks

How can one create new scopes in python

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在许多语言(和地方)中，通过创建像这样的块来创建本地作用域是一种很好的实践。void foo(){     ... Do some stuff ...     if(TRUE)     {         char a;         int b;         ... Do some more stuff ...     }     ... Do even more stuff ... }我

问如何在python中创建新的作用域？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在python中创建新的作用域？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在python中创建新的作用域？
EN