blocks|key|1279571|text|在您的版本中，您创建了两个文件处理程序(类似于原始示例中的baconFile+)，每次调用open时都会创建一个处理程序，它们处理相同的文件。baconFile+不是一个文件，它是一个处理文件的对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|1279572|你用来写一些文本的第一个。你永远不会关闭它，当你的程序结束时，它将被销毁。|1279573|当您在w模式下打开第二个文件时，它将重置文本内容，然后您将其关闭。|1279574|entityMap^0|T|9|19|4|1Z|9|1Z|9|29|F|0|0|3|1|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|D]|$9|V|A|W|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|X|8|@]|E|@]|F|$]]|$1|I|3|J|5|6|7|Y|8|@$9|Z|A|10|B|C]]|E|@]|F|$]]|$1|K|3|-4|5|6|7|11|8|@]|E|@]|F|$]]]|L|$]]

In your version, you create two file handlers (like <code>baconFile</code> in the original example), one for each time you call <code>open</code>, and they handle the same file. <code>baconFile</code> is not a file, it is an object to handle files.

The first one you use to write some text. You never close and it will be destroyed when you program ends. 

When you open the second one in <code>w</code> mode, it resets the text content, and then you close it.

blocks|key|1152359|text|step+1.+open+the+file+to+write.
step+2.+write+something+in+the+file.
step+3.+close+the+file.|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1152360|您正在尝试打开一个打开的文件。|unstyled|1152361|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>step 1. open the file to write.
step 2. write something in the file.
step 3. close the file.
</code></pre>

you are trying to open a opened file.

blocks|key|2167711|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2167712|，我认为变量只是我不想再输入的代码的替代品。|blockquote|2167713|2167714|2167715|这是一个外行术语对的描述。|2167716|只有当你在处理纯函数，即没有副作用的函数时，它才有效。例如,|2167717|def+double(x):
++++return+2+*+x

a+=+double(5)
b+=+a+%2B+a|code-block|syntax|javascript|2167718|等同于|2167719|b+=+double(5)+%2B+double(5)|2167720|但在Python中，函数通常不是纯函数。Assignment的工作方式是对右侧求值一次，然后将其绑定到左侧的名称。使用名称仅引用计算表达式的值，但不会重复其可能产生的副作用。|2167721|所以如果相反，|2167722|def+double(x):
++++print('doubling',+x)
++++return+2+*+x|2167723|然后|2167724|a+=+double(5)
b+=+a+%2B+a|2167725|不再等同于|2167726|b+=+double(5)+%2B+double(5)|2167727|在这两种情况下，b仍然是20，但是第一种情况打印doubling+5一次，第二种情况打印两次。|offset|length|style|CODE|2167728|2167729|open('bacon.txt',+'w')有打开文件并截断它的副作用，它的计算结果是一个值，即文件句柄。|2167730|在您的示例中，|2167731|open('bacon.txt',+'w').write('Bacon+is+not+a+vegetable.')
open('bacon.txt',+'w').close()|2167732|等同于：|2167733|f+=+open('bacon.txt',+'w')
f.write('Bacon+is+not+a+vegetable.')

g+=+open('bacon.txt',+'w')
g.close()|2167734|这意味着文件被打开并被截断一次，然后向其中写入一些内容。然后，它被打开并再次被截断，丢失了您之前编写的内容。|2167735|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|8|1|O|A|0|0|0|M|0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|1R|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|1S|7|@]|8|@]|9|$]]|$1|D|3|-4|4|5|6|1T|7|@]|8|@]|9|$]]|$1|E|3|-4|4|5|6|1U|7|@]|8|@]|9|$]]|$1|F|3|G|4|5|6|1V|7|@]|8|@]|9|$]]|$1|H|3|I|4|5|6|1W|7|@]|8|@]|9|$]]|$1|J|3|K|4|L|6|1X|7|@]|8|@]|9|$M|N]]|$1|O|3|P|4|5|6|1Y|7|@]|8|@]|9|$]]|$1|Q|3|R|4|L|6|1Z|7|@]|8|@]|9|$M|N]]|$1|S|3|T|4|5|6|20|7|@]|8|@]|9|$]]|$1|U|3|V|4|5|6|21|7|@]|8|@]|9|$]]|$1|W|3|X|4|L|6|22|7|@]|8|@]|9|$M|N]]|$1|Y|3|Z|4|5|6|23|7|@]|8|@]|9|$]]|$1|10|3|11|4|L|6|24|7|@]|8|@]|9|$M|N]]|$1|12|3|13|4|5|6|25|7|@]|8|@]|9|$]]|$1|14|3|15|4|L|6|26|7|@]|8|@]|9|$M|N]]|$1|16|3|17|4|5|6|27|7|@$18|28|19|29|1A|1B]|$18|2A|19|2B|1A|1B]]|8|@]|9|$]]|$1|1C|3|-4|4|5|6|2C|7|@]|8|@]|9|$]]|$1|1D|3|1E|4|5|6|2D|7|@$18|2E|19|2F|1A|1B]]|8|@]|9|$]]|$1|1F|3|1G|4|5|6|2G|7|@]|8|@]|9|$]]|$1|1H|3|1I|4|L|6|2H|7|@]|8|@]|9|$M|N]]|$1|1J|3|1K|4|5|6|2I|7|@]|8|@]|9|$]]|$1|1L|3|1M|4|L|6|2J|7|@]|8|@]|9|$M|N]]|$1|1N|3|1O|4|5|6|2K|7|@]|8|@]|9|$]]|$1|1P|3|-4|4|5|6|2L|7|@]|8|@]|9|$]]]|1Q|$]]

<blockquote>
 I thought a variable was just a substitute for whatever code I didn't want to type again.
</blockquote>

This is a description of <a href="https://en.wikipedia.org/wiki/Referential_transparency" rel="nofollow noreferrer">referential transparency</a> in layman's terms.

It works only if you are dealing with pure functions, i.e. functions which have no side effects. For example,

<pre><code>def double(x):
 return 2 * x

a = double(5)
b = a + a
</code></pre>

is equivalent to

<pre><code>b = double(5) + double(5)
</code></pre>

But in Python, functions are in general not pure. Assignment works by evaluating the right-hand side once and binding it to the name on the left-hand side. Using the name only refers to the value of the evaluated expression, but does not repeat the side effects it could have had.

So if instead,

<pre><code>def double(x):
 print('doubling', x)
 return 2 * x
</code></pre>

then

<pre><code>a = double(5)
b = a + a
</code></pre>

is no longer equivalent to

<pre><code>b = double(5) + double(5)
</code></pre>

<code>b</code> is still 20 in both cases, but the first case prints <code>doubling 5</code> once, the second case prints it twice.

<hr>

<code>open('bacon.txt', 'w')</code> has a side effect of opening a file and truncating it, and evaluates to a value which is a file handle.

In your example,

<pre><code>open('bacon.txt', 'w').write('Bacon is not a vegetable.')
open('bacon.txt', 'w').close()
</code></pre>

is equivalent to:

<pre><code>f = open('bacon.txt', 'w')
f.write('Bacon is not a vegetable.')

g = open('bacon.txt', 'w')
g.close()
</code></pre>

Which means that the file is opened and truncated once, then something is written to it. Then it is opened and truncated again, losing what you've written before.

I'm working through Automate the Boring Stuff, and I noticed he teaches the open module as:

<pre><code>baconFile = open('bacon.txt', 'w')
baconFile.write('Bacon is not a vegetable.')
baconFile.close()
</code></pre>

Why do we need the baconFile variable at all? I understand ease of readability/debugging, however, when I try the following code, the text is not input into the .txt file:

<pre><code>open('bacon.txt', 'w').write('Bacon is not a vegetable.')
open('bacon.txt', 'w').close()
</code></pre>

Why? What is the difference between these two?

Edit: People are saying I'm opening it again in the code at the bottom. Is that not what I'm doing in the top code? I thought a variable was just a substitute for whatever code I didn't want to type again.

Automate the Boring Stuff: Why don't these Python functions do the same thing?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在学习Automate那些无聊的东西，我注意到他教开放模块是这样的：baconFile = open('bacon.txt', 'w')baconFile.write('Bacon is not a vegetable.')baconFile.close()为什么我们需要baconFile变量呢？我理解易于阅读/调...

问自动化那些无聊的东西:为什么这些Python函数不做同样的事情呢？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问自动化那些无聊的东西:为什么这些Python函数不做同样的事情呢？EN