# Two key points of Python deconstruction and encapsulation

The following article comes from Tencent cloud, written by brother Liang in the workplace

(want to learn Python? Python learning exchange group: 1039649593, meet your needs. All materials have been uploaded to the group file stream and can be downloaded by yourself! There are also a large number of the latest 2020 Python learning materials.)

### Python deconstruction and encapsulation

Look at the following code first

```x = 1
y = 2

tmp = x
x = y
y = tmp

print(x, y)
```

The output of the code is: 2 1

Look at the following code:

```x = 1
y = 2

x, y = y, x
print(x, y)
```

The output of the code is: 2 1

x. The meaning behind the code y = y, X is deconstruction and encapsulation

### Python encapsulation

```In [1]: t = 1, 2

In [2]: t
Out[2]: (1, 2)

In [3]: type(t)
Out[3]: tuple			# Parentheses can be omitted when defining tuples

In [4]: t1 = (1, 2)

In [5]: t2 = 1, 2
# t1 and t2 are equivalent
In [6]: t1
Out[6]: (1, 2)

In [7]: t2
Out[7]: (1, 2)
```

Therefore, the encapsulated result must be tuples.

x. Y = y, x the right side of the code will be encapsulated as (y, x)

### Python deconstruction

##### Basic deconstruction
```In [8]: lst = [1, 2]

In [9]: first, second = lst

In [10]: print(first, second)
1 2
```

Assign the elements of the linear structure lst to the variables first and second according to the element order

##### Asterisk deconstruction
```In [11]: lst = list(range(5))

In [12]: head, *tail = lst

Out[13]: 0

In [14]: tail
Out[14]: [1, 2, 3, 4]

In [15]: *lst2 = lst	# There must be a variable with an asterisk on the left
File "<ipython-input-15-98211a44ccfb>", line 1
*lst2 = lst
^
SyntaxError: starred assignment target must be in a list or tuple

In [16]: *head, tail = lst

Out[17]: [0, 1, 2, 3]

In [18]: lst
Out[18]: [0, 1, 2, 3, 4]

In [19]: tail
Out[19]: 4

In [20]: head, *m1, *m2, tail = lst		# There cannot be more than one asterisk. There can only be one asterisk
File "<ipython-input-20-1fc1a52caa8e>", line 1
head, *m1, *m2, tail = lst
^
SyntaxError: two starred expressions in assignment

In [21]: v1, v2, v3, v4, v5, v6, v7 = lst	# The number of variables on the left cannot exceed the number of elements on the right
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-21-9366cfb498a1> in <module>()
----> 1 v1, v2, v3, v4, v5, v6, v7 = lst

ValueError: not enough values to unpack (expected 7, got 5)

In [22]: v1, v2 = lst						#The number of variables on the left cannot be less than the number of elements on the right
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-22-d7b0a4e7871e> in <module>()
----> 1 v1, v2 = lst

ValueError: too many values to unpack (expected 2)

```

### It can be summarized as the following rules:

• Elements are assigned to variables in order
• Variables and elements must match
• Asterisk variables can accept any number of elements
• Variables with asterisks cannot appear alone

### Multilevel deconstruction

Deconstruction supports multiple levels

```In [23]: lst = [1, (2, 3), 5]

In [24]: _, v, *_ = lst		# v resolves to (2, 3)

In [25]: v
Out[25]: (2, 3)

In [26]: _, val = v			# v can be further deconstructed

In [27]: val
Out[27]: 3

In [28]: _, (_, val), *_ = lst		# It can be deconstructed in one step

In [29]: val
Out[29]: 3

In [30]: _, [*_, val], *_ = lst		# Middle part solution composition list

In [31]: val
Out[31]: 3

In [32]: _, _, val, *_ = lst		# (2, 3) parse into the second_

In [33]: val
Out[33]: 5
```
##### Use of Python underscores

Use single underline_ Indicates that the variable is discarded, which is a python convention. A single underscore is also a legal identifier for Python, but if you don't want to discard a variable, you usually don't use a single underscore to represent a meaningful variable. It can be understood as a convention.

##### Use of deconstruction and encapsulation

For very complex data structures and multi-layer nested linear structures, deconstruction can be used to quickly extract the values, which is very convenient

For example, the following usage methods

```In [1]: key, _, value = 'I love Python'.partition(' love ')

In [2]: key
Out[2]: 'I'

In [3]: value
Out[3]: 'Python'
```

Tags: Python

Posted by cshinteractive on Sun, 08 May 2022 12:08:08 +0300