blocks|key|1535517|text|这是一个只有一个元组的列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1535518|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|$]]

blocks|key|4561430|text|因为还没有人回答这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4561431|4561432|一个元组？(或者他们怎么叫它？)|blockquote|4561433|4561434|4561435|"tuple“这个词来源于数学。在数学中，如果我们在做二维几何，我们可能会讨论(有序的)对。移动到三维意味着我们需要三个维度。在更高的维度中，我们需要四元组，五元组，以及，呃，无论六的前缀是什么，等等。这开始成为一种痛苦，数学家也喜欢泛化(“让我们今天在n维工作！”)，所以他们开始使用术语"n-tuple“来表示n个事物(通常是数字)的有序列表。|4561436|在那之后，只需要一点自然的懒惰就可以去掉"n-“，我们就得到了元组。|4561437|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|O|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|P|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|S|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|M|$]]

Since no one has answered this bit yet:

<blockquote>
 A tuple? ( or whatever they call it? ) 
</blockquote>

The word "tuple" comes from maths. In maths, we might talk about (ordered) pairs, if we're doing 2d geometry. Moving to three dimensions means we need triples. In higher dimensions, we need quadruples, quintuples, and, uh, whatever the prefix is for six, and so on. This starts to get to be a pain, and mathematicians also love generalising ("let's work in n dimensions today!"), so they started using the term "n-tuple" for an ordered list of n things (usually numbers).

After that, a bit of natural laziness is all you need to drop the "n-" and we end up with tuples.

blocks|key|4561291|text|请注意这一点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4561292|("is+not+a+tuple")|code-block|syntax|javascript|4561293|元组由逗号定义，长度为零的元组除外。这一点：|4561294|"is+a+tuple",|4561295|因为末尾有逗号。括号只是强制分组(同样，除了长度为零的元组的情况。|4561296|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Note that this:

<pre><code>("is not a tuple")
</code></pre>

A tuple is defined by the commas, except in the case of the zero-length tuple. This:

<pre><code>"is a tuple",
</code></pre>

because of the comma at the end. The parentheses just enforce grouping (again, except in the case of a zero-length tuple.

blocks|key|1344756|text|这是一个元组列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1344757|这是一个整数列表：[1,+2,+3,+4,+5]|offset|length|style|CODE|1344758|这也是一个整数列表：[1]|1344759|这是一个(字符串，整数)元组：("hello+world",+42)|1344760|这是(字符串，整数)元组的列表：[("a",+1),+("b",+2),+("c",+3)]|1344761|这就是：[("a",+1)]|1344762|在Python中，列表和元组没有太大区别。然而，它们在概念上是不同的。一种简单的想法是，一个列表包含许多相同类型的项(同构)，而一个元组包含固定数量的不同类型的项(异类)。记住这一点的一个简单方法是，列表可以被追加，而元组不能，因为追加到列表是有意义的，而追加到元组是没有意义的。|1344763|Python不强制执行这些区别--在Python中，您可以使用%2B附加到元组，或者将异构类型存储在列表中。|1344764|entityMap^0|0|9|F|0|A|3|0|F|J|0|G|U|0|4|A|0|0|V|1|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@$D|X|E|Y|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|15|8|@$D|16|E|17|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1B|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1C|8|@$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]]|U|$]]

That's a list of tuples.

This is a list of integers: <code>[1, 2, 3, 4, 5]</code>

This is also a list of integers: <code>[1]</code>

This is a (string, integer) tuple: <code>("hello world", 42)</code>

This is a list of (string, integer) tuples: <code>[("a", 1), ("b", 2), ("c", 3)]</code>

And so is this: <code>[("a", 1)]</code>

In Python, there's not much difference between lists and tuples. However, they are conceptually different. An easy way to think of it is that a list contains lots of items of the same type (homogeneous) , and a tuple contains a fixed number of items of different types (heterogeneous). An easy way to remember this is that lists can be appended to, and tuples cannot, because appending to a list makes sense and appending to a tuple doesn't.

Python doesn't enforce these distinctions -- in Python, you can append to a tuple with <code>+</code>, or store heterogeneous types in a list.

blocks|key|235838|text|是的，它是一个tuple。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|235839|它们看起来像这样：|235840|()
(foo,)
(foo,+bar)
(foo,+bar,+baz)|code-block|syntax|javascript|235841|等。|235842|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.python.org/tutorial/datastructures.html#tuples-and-sequences^0|7|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Yes, it's a <a href="http://docs.python.org/tutorial/datastructures.html#tuples-and-sequences" rel="nofollow noreferrer">tuple</a>.

They look like this:

<pre><code>()
(foo,)
(foo, bar)
(foo, bar, baz)
</code></pre>

etc.

blocks|key|235843|text|[('/',+MainPage)]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|235844|这是一个包含两个元素的元组的列表。|unstyled|235845|()|235846|这是一个零元素元组。|235847|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|F|7|Q|8|@]|9|@]|A|$]]]|L|$]]

<pre><code>[('/', MainPage)]
</code></pre>

That's a list consisting of a two element tuple.

<pre><code>()
</code></pre>

That's a zero element tuple.

blocks|key|1537667|text|它是元组的列表。您可以通过以下方式进行验证|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1537668|x=[('/',+MainPage)]
print+type(x)+#+You+will+find+a+<list>+type+here
print+type(x[0])+#+You+will+find+a+<tuple>+type+here|code-block|syntax|javascript|1537669|您可以使用下面的代码从这种类型的结构(列表中可能有更多的元组)构建字典|1537670|my_dict+=+dict(x)+#+x=[('/',MainPage)]|1537671|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|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It is a list of tuple(s). You can verify that by

<pre><code>x=[('/', MainPage)]
print type(x) # You will find a &lt;list&gt; type here
print type(x[0]) # You will find a &lt;tuple&gt; type here
</code></pre>

You can build a dictionary from this type of structure (may be more tuple inside the list) with this code

<pre><code>my_dict = dict(x) # x=[('/',MainPage)]
</code></pre>

blocks|key|1535665|text|它是包含一个元组的元组列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1535666|元组就像一个列表，只是它是不可变的，这意味着它一旦创建就不能改变。您不能添加、删除或更改元组中的元素。如果您希望您的元组不同，则必须使用新数据创建新的元组。这听起来可能很痛苦，但实际上元组在代码安全性和速度方面都有很多好处。|1535667|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|$]]

It is a list of tuples containing one tuple.

A tuple is just like a list except that it is immutable, meaning that it can't be changed once it's created. You can't add, remove, or change elements in a tuple. If you want your tuple to be different, you have to create a new tuple with the new data. This may sound like a pain but in reality tuples have many benefits both in code safety and speed.

blocks|key|4561465|text|它只是一个元组的列表。这个元组有两个元素，一个字符串和一个对象MainPage。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4561466|列表和元组都是有序的对象组，不管是什么类型的对象，它们在这两种情况下都可以是异构的。|4561467|列表和元组之间的主要区别是元组是不可变的，就像字符串一样。|BOLD|4561468|例如，我们可以定义一个列表和一个元组：|4561469|>>>+L+=+['a',+1,+5,+'b']
>>>+T+=+('a',+1,+5,+'b')|code-block|syntax|javascript|4561470|我们可以简单地通过赋予L的元素一个新值来修改它们|4561471|>>>+print+L
['a',+1,+5,+'b']
>>>+L[1]+=+'c'
>>>+print+L
['a',+'c',+5,+'b']|4561472|对于元组则不是这样|4561473|>>>+print+T
('a',+1,+5,+'b')
>>>+T[1]+=+'c'
Traceback+(most+recent+call+last):
++File+"<stdin>",+line+1,+in+<module>
TypeError:+'tuple'+object+does+not+support+item+assignment|4561474|这是因为它们是不可变的。元组的元素可以是可变的，您可以修改它们，例如：|4561475|>>>+T+=+(3,+['a',+1,+2],+'lol')
>>>+T[1]
['a',+1,+2]
>>>+T[1][0]+=+'b'
>>>+T
(3,+['b',+1,+2],+'lol')|4561476|但是我们编辑的列表仍然是同一个对象，我们没有替换元组的元素。|4561477|entityMap^0|V|8|0|0|D|7|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@$9|18|A|19|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1A|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1B|8|@$9|1C|A|1D|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|1E|8|@]|D|@]|E|$]]|$1|M|3|N|5|O|7|1F|8|@]|D|@]|E|$P|Q]]|$1|R|3|S|5|6|7|1G|8|@]|D|@]|E|$]]|$1|T|3|U|5|O|7|1H|8|@]|D|@]|E|$P|Q]]|$1|V|3|W|5|6|7|1I|8|@]|D|@]|E|$]]|$1|X|3|Y|5|O|7|1J|8|@]|D|@]|E|$P|Q]]|$1|Z|3|10|5|6|7|1K|8|@]|D|@]|E|$]]|$1|11|3|12|5|O|7|1L|8|@]|D|@]|E|$P|Q]]|$1|13|3|14|5|6|7|1M|8|@]|D|@]|E|$]]|$1|15|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|16|$]]

It's a list of just one tuple. That tuple has two elements, a string and the object <code>MainPage</code> whatever it is.

Both lists and tuples are ordered groups of object, it doesn't matter what kind of object, they can be heterogeneous in both cases.

The main difference between lists and tuples is that tuples are immutable, just like strings.

For example we can define a list and a tuple:

<pre><code>&gt;&gt;&gt; L = ['a', 1, 5, 'b']
&gt;&gt;&gt; T = ('a', 1, 5, 'b')
</code></pre>

we can modify elements of L simply by assigning them a new value

<pre><code>&gt;&gt;&gt; print L
['a', 1, 5, 'b']
&gt;&gt;&gt; L[1] = 'c'
&gt;&gt;&gt; print L
['a', 'c', 5, 'b']
</code></pre>

This is not true for tuples

<pre><code>&gt;&gt;&gt; print T
('a', 1, 5, 'b')
&gt;&gt;&gt; T[1] = 'c'
Traceback (most recent call last):
 File "&lt;stdin&gt;", line 1, in &lt;module&gt;
TypeError: 'tuple' object does not support item assignment
</code></pre>

This is because they are immutable.
Tuples' elements may be mutable, and you can modify them, for example:

<pre><code>&gt;&gt;&gt; T = (3, ['a', 1, 2], 'lol')
&gt;&gt;&gt; T[1]
['a', 1, 2]
&gt;&gt;&gt; T[1][0] = 'b'
&gt;&gt;&gt; T
(3, ['b', 1, 2], 'lol')
</code></pre>

but the list we edited is still the same object, we didn't replaced the tuple's element.

What is this called in python:

<pre><code>[('/', MainPage)]
</code></pre>

Is that an array .. of ... erhm one dictionary? 

Is that

<pre><code>()
</code></pre>

A tuple? ( or whatever they call it? )

What is this construct called in python: ( x, y )

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

这在python中叫什么：[('/', MainPage)]那是一个数组吗..对..。一本字典？是这样吗？()元组？(或者他们怎么叫它？)

问这个结构在python中叫什么：( x，y)
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这个结构在python中叫什么：( x，y)EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问这个结构在python中叫什么：( x，y)
EN