Python有趣的解包用法

python中的解包可以这样理解:一个list是一个整体,想把list中每个元素当成一个个个体剥离出来,这个过程就是解包,我们来看下面这些例子(分为10个部分)。

1.将list中每个元素赋值给一个变量

>>> name, age, date = ['Bob', 20, '2018-1-1']
>>> name
'Bob'
>>> age
20
>>> date
'2018-1-1'

2.可迭代对象都可以这样做

# 列表
>>> a,b,c = ['a', 'b', 'c']
>>> a
'a'

>>> a,b,c = enumerate(['a', 'b', 'c'])
>>> a
(0, 'a')


# 元组
>>> a,b,c = ('a', 'b', 'c')
>>> a
'a'

# 字典
>>> a,b,c = {'a':1, 'b':2, 'c':3}
>>> a
'a'

>>> a,b,c = {'a':1, 'b':2, 'c':3}.items()
>>> a
('a', 1)


# 字符串
>>> a,b,c = 'abc'
>>> a
'a'

# 生成器
>>> a,b,c = [x + 1 for x in range(3)]
>>> a
1

如果可迭代对象包含的元素和前面待赋值变量数量不一致,则会报错。但是可以通过*来表示多个元素

3.星号的使用

比如我们要计算平均分,去除最高分和最低分,除了用切片,还可以用解包的方式获得中间的数值

>>> first, *new, last = [94, 85, 73, 46]
>>> new
[85, 73]

用*来表示多个数值

4.压包过程

压包是解包的逆过程,用zip函数实现,下面例子可以对压包有一个直观的感受

>>> a = ['a', 'b', 'c']
>>> b = [1, 2, 3]
>>> for i in zip(a, b):
...     print(i)
...
('a', 1)
('b', 2)
('c', 3)

5.压包与解包混合的例子

下面例子实现:两个列表对应数值相加

>>> a = [0, 1, 2]
>>> b = [1, 2, 3]
>>> for i, j in zip(a, b):
...     print(i+j)
...
1
3
5

细细拆解上面过程,可以看出步骤是这样的

  • 先是zip函数将a b压包成为一个可迭代对象
  • 对可迭代对象的每一个元素(('a', 1))进行解包(i, j = ('a', 1))
  • 此时就可以分别调用i j变量进行计算 下面我们加入星号
>>> l = [('Bob', '1990-1-1', 60),
...     ('Mary', '1996-1-4', 50),
...     ('Nancy', '1993-3-1', 55),]
>>> for name, *args in l:
...     print(name, args)
...
Bob ['1990-1-1', 60]
Mary ['1996-1-4', 50]
Nancy ['1993-3-1', 55]

6._的用法

当一些元素不用时,用_表示是更好的写法,可以让读代码的人知道这个元素是不要的

>>> person = ('Bob', 20, 50, (11, 20, 2000))
>>> name, *_, (*_, year) = person
>>> name
'Bob'
>>> year
2000

7.多变量同时赋值

之前赋值符号右侧都是可迭代对象,其实右侧也可以是多个变量

>>> a, b = 1, 2
>>> a
1
>>> b
2
>>> a = 1, 2
>>> a
(1, 2)

下面用法都会报错

*a = 1, 2
a, b, c = 1, 2

可以这样

*a, = 1, 2

8.*之可变参数

函数定义时,我们使用*的可变参数,其实也是压包解包过程

>>> def myfun(*num):
...     print(num)
...
>>> myfun(1,2,5,6)
(1, 2, 5, 6)

参数用*num表示,num变量就可以当成元组调用了。

其实这个过程相当于*num, = 1,2,5,6

9.*之关键字参数

>>> def myfun(**kw):
...     print(kw)
...
>>> myfun(name = "Bob", age = 20, weight = 50)
{'weight': 50, 'name': 'Bob', 'age': 20}

键值对传入**kw,kw就可以表示相应字典。

**的用法只在函数定义中使用,不能这样使用

a, **b = {'weight': 50, 'name': 'Bob', 'age': 20}

10.可变参数与关键字参数的细节问题

(1)函数传入实参时,可变参数(*)之前的参数不能指定参数名

>>> def myfun(a, *b):
...     print(a)
...     print(b)
...
>>> myfun(a=1, 2,3,4)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

>>> myfun(1, 2,3,4)
1
(2, 3, 4)

(2)函数传入实参时,可变参数(*)之后的参数必须指定参数名,否则就会被归到可变参数之中

>>> def myfun(a, *b, c=None):
...     print(a)
...     print(b)
...     print(c)
...
>>> myfun(1, 2,3,4)
1
(2, 3, 4)
None
>>> myfun(1, 2,3,c=4)
1
(2, 3)
4

如果一个函数想要使用时必须明确指定参数名,可以将所有参数都放在可变参数之后,而可变参数不用管它就可以,也不用命名,如下

>>> def myfun(*, a, b):
...     print(a)
...     print(b)
...
>>> myfun(a = 1,b = 2)
1
2

可变参数的这两条特性,可以用于将 只需要按照位置赋值的参数 和 需要明确指定参数名的参数区分开来

(3)关键字参数都只能作为最后一个参数,前面的参数按照位置赋值还是名称赋值都可以

下面展示一个既用可变参数有用关键字参数的例子

>>> def myfun(a, *b, c, **d):
...     print(a)
...     print(b)
...     print(c)
...     print(d)
...
>>> myfun(1, 2, 3, c= 4, m = 5, n = 6)
1
(2, 3)
4
{'n': 6, 'm': 5}

(4)可变参数与关键词参数共同使用以表示任意参数

下面是这一点在装饰器当中的使用

>>> def mydecorator(func):
...     def wrapper(*args, **kw):
...         print('I am using a decorator.')
...         return func(*args, **kw)
...     return wrapper
...
>>> @mydecorator
... def myfun(a, b):
...     print(a)
...     print(b)
...
>>> myfun(1, b = 2)
I am using a decorator.
1
2

(如果有的读者不熟悉装饰器,只需要知道,使用@定义myfun相当于myfun = mydecorator(myfun),定义出来的myfun其实是返回结果wrapper函数)

wrapper函数使用args, *kw作为参数,则被修饰的myfun函数需要的参数无论是什么样的,传入wrapper都不会报错,这保证了装饰器可以修饰各种各样函数的灵活性。毕竟我们一般在函数中传入参数时,要么所有参数名都写,要么前面几个不写,后面的会写,这样使用args, *kw完全没有问题。

11.解包作为参数传入函数中

首先定义一个函数

def myfun(a, b):
    print(a + b)

列表元组的解包

>>> n = [1, 2]
>>> myfun(*n)
3
>>> m = (1, 2)
>>> myfun(*m)
3

字典的解包

>>> mydict = {'a':1, 'b': 2}
>>> myfun(**mydict)
3
>>> myfun(*mydict)
ba

一个应用

>>> bob = {'name': 'Bob', 'age': 30}
>>> "{name}'s age is {age}".format(**bob)
"Bob's age is 30"

12.多返回值函数

下面过程也涉及到了解包

def myfun(a, b):
    return a + 1, b + 2
>>> m, n = myfun(1, 2)
>>> m
2
>>> n
4

其实本身是一个元组

>>> p = myfun(1, 2)
>>> p
(2, 4)

Dwzb,对数据分析很感兴趣,课余学习统计软件R和python。关注科技,互联网的发展与变革

专栏:https://zhuanlan.zhihu.com/python-programming

原文发布于微信公众号 - Python中文社区(python-china)

原文发表时间:2018-04-06

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏女程序员的日常

值类型和引用类型的区别,struct和class的区别

C#值类型和引用类型 1、简单比较   值类型的变量直接存储数据,而引用类型的变量持有的是数据的引用,数据存储在数据堆中。   值类型(value type):...

25310
来自专栏Crossin的编程教室

【编程课堂】计数器 Counter

上一期的编程课堂我们介绍了 有序字典 OrderedDict,这一期我们再来聊聊 同属 collections 模块的另一种数据类型 Counter。 在了解 ...

30260
来自专栏工科狗和生物喵

【计算机本科补全计划】Java学习笔记(二) 基础语法红黄蓝

正文之前 刚才突然想起来自己CCF报名还没报名成功,就是一阵心绞痛,明晚就截止了,要是没报上,到时候怎么跟老师交差,突然想起来,如果老师问我最近干了啥,可以用准...

38060
来自专栏Pythonista

Golang笔记之变量

8920
来自专栏Pythonista

面向对象进阶

反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身状态或行为的一种能力(自省)。这一概念的提出很快引发了计算机科学领域关于应...

8420
来自专栏C/C++基础

Google C++编程风格指南(四)之类的相关规范

类是C++中基本的代码单元,自然被广泛使用。本节列举了在写一个类时要做什么、不要做什么。

11520
来自专栏增长技术

swift体验1

一门新语言传统的入门方式是在屏幕上打印“Hello,wrold”。在Swift中你可以用下面一行 代码:

11340
来自专栏Pythonista

golang之指针

接受者变量代表的值实际上是源值的复制品。如果这个值不是指针类型,在值方法中就没有途径去改变源值。

11130
来自专栏信数据得永生

JavaScript 编程精解 中文第三版 九、正则表达式

31860
来自专栏Python专栏

Python | 5分钟搞定 Python3 元组

元组(tuple)是一种静态的(immutable)或者说是不可变(unchangeable)的数据结构,里面的元素按照一定的顺序排列。它是静态的,所以元组里的...

23820

扫码关注云+社区

领取腾讯云代金券