[已解决]可以用list为tuple赋值？搞不懂

成亟亟

>>> l = [4,5,6]
>>> (mydic['id'],mydic['name'],mydic['sex']) = l            #左侧是tuple，右侧是list，居然可以直接这么划等号是为什么？
>>> type((mydic['id'],mydic['name'],mydic['sex']))
<class 'tuple'>
>>> (mydic['id'],mydic['name'],mydic['sex'])
(4, 5, 6)

谢谢

最佳答案

月排行榜 / 总排行榜

sunrise085

2020-4-26 15:16:00

这就是规定啊，多变量赋值就是如此，左边加不加括号都可以，不加括号就是多个独立变了，加上括号，就是一个元组
多变量赋值，右侧可以是多个变量，可以是一个元组，也可以是一个列表

list1=[1,2,32]
b,c,d=list1
print(b,c,d)
b,c,d=3,6,1
print(b,c,d)
(b,c,d)=(5,8,13)
print(b,c,d)

跳转到最佳答案楼层

wuqramy

实践出真理，可以

成亟亟

wuqramy 发表于 2020-4-26 14:40
实践出真理，可以

谢谢您的关注和回复

sunrise085

这就是规定啊，多变量赋值就是如此，左边加不加括号都可以，不加括号就是多个独立变了，加上括号，就是一个元组
多变量赋值，右侧可以是多个变量，可以是一个元组，也可以是一个列表

list1=[1,2,32]
b,c,d=list1
print(b,c,d)
b,c,d=3,6,1
print(b,c,d)
(b,c,d)=(5,8,13)
print(b,c,d)

成亟亟

sunrise085 发表于 2020-4-26 15:16
这就是规定啊，多变量赋值就是如此，左边加不加括号都可以，不加括号就是多个独立变了，加上括号，就是一个 ...

谢谢您的耐心回复。

成亟亟

A list display is a possibly empty series of expressions enclosed in square brackets:(6.2.5. List display)
list_display ::=  "[" [starred_list | comprehension] "]"

Except when part of a list or set display, an expression list containing at least one comma yields a tuple: (6.15 Expression lists)
expression_list    ::=  expression ("," expression)* [","]
An asterisk * denotes iterable unpacking. Its operand must be an iterable. The iterable is expanded into a sequence of items, which are included in the new tuple, list, or set, at the site of the unpacking.
The trailing comma is required only to create a single tuple (a.k.a. a singleton); it is optional in all other cases. A single expression without a trailing comma doesn’t create a tuple, but rather yields the value of that expression. (To create an empty tuple, use an empty pair of parentheses: ().)

Assignment statements are used to (re)bind names to values and to modify attributes or items of mutable objects: (7.2 Assignment statements)
assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list           ::=  target ("," target)* [","]
target                 ::=  identifier
                              | "(" [target_list] ")"
                              | "[" [target_list] "]"
An assignment statement evaluates the expression list (remember that this can be a single expression or a comma-separated list, the latter yielding a tuple) and assigns the single resulting object to each of the target lists, from left to right.
Assignment is defined recursively depending on the form of the target (list). When a target is part of a mutable object, the mutable object must ultimately perform the assignment and decide about its validity, and may raise an exception if the assignment is unacceptable.
Assignment of an object to a target list, optionally enclosed in parentheses or square brackets, is recursively defined as follows.
        If the target list is a single target with no trailing comma, optionally in parentheses, the object is assigned to that target.
        ! Else: The object must be an iterable with the same number of items as there are targets in the target list, and the items are assigned, from left to right, to the corresponding targets.
                            ... ...

楠戦獞鎵撲繚鍖

学习了，谢谢

成亟亟

The statement t = 12345, 54321, 'hello!' is an example of tuple packing: the values 12345, 54321 and 'hello!' are packed together in a tuple.
The reverse operation is also possible:

>>> x, y, z = t

This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side.
Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence.
Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.

參考：https://docs.python.org/3.8/tuto ... uples-and-sequences