Python进阶03_元组的理解_name country population coordinates-优快云博客

本文链接：https://blog.youkuaiyun.com/fioletfly/article/details/100015005

本文深入探讨了Python中元组的两大核心功能：作为不可变列表和数据记录。详细讲解了元组拆包和平行赋值，介绍了如何使用具名元组增强数据的语义性和可读性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

元组的理解

元组的两大功能
- 作为不可变列表
- 作为数据记录

元组和记录

元组其实是对数据的记录：元组中的每个元素都存放了记录中一个字段的数据，外加这个字段的位置。正是这个位置信息给数据赋予了意义。

如果在任何的表达式里我们在元组内对元素排序，这些元素所携带的信息就会丢失，因为这些信息是跟它们的位置有关的。

元组的记录功能：通过数量和位置信息体现，拆包让元组可以完美地被当作记录来使用。

gps_coordinates = (33.1,-118.11)
city,year,pop,chg = ('sz','2019','1500','0.8')
EMS_ids = [('sz','518000'),('ja','316000')]

for id in sorted(EMS_ids):
    print('%s/%s' % id)
# 提取元组中的元素-拆包（unpacking）  
# 利用“_”作为占位符
for ad,_ in EMS_ids:
    print(ad)

ja/316000
sz/518000
sz
ja

元组拆包

元组拆包的体现：

把元组里面的元素赋值给对应的变量：city,year,pop,chg = ('sz','2019','1500','0.8')
把对应的元素呈现给对应的函数形参：print('%s/%s' % id)

所以元组的拆包简单的理解：提取元组的元素。至于提前后是用于赋值变量还是打印参数，这个可以根据实际的情况来使用。

元组拆包的使用场景

平行赋值
最好辨认的元组拆包形式，把元组里面的元素赋值给对应的变量。

交换两个变量的值
b,a = a,b

’*'运算符把一个可迭代对象拆开

让一个函数可以用元组的形式返回多个值
比如 os.path.split() 函数就会返回以路径和最后一个文件名组成的元组 (path, last_part)

用* 来处理剩下的元素

在 Python 中，函数用 *args 来获取不确定数量的参数算,在平行赋值中，* 前缀只能用在一个变量名前面，但是这个变量可以出现在赋值表达式的任意位置。

#平行赋值
lax_coordinates = (31.1111,188.98763)
lat,lng = lax_coordinates
print(lax_coordinates)
print(lat)
print(lng)

#交换两个变量的值
a = 100
b = 200
print('a:',a,'b:',b)
b,a = a,b
print('a:',a,'b:',b)

#  * 运算符把一个可迭代对象拆开作为函数的参数
print(divmod(20,8))
t = (20,8)
print(divmod(*t))
q,t = divmod(*t)
print(q,t)

# 让一个函数可以用元组的形式返回多个值
# 使用_占位符表示忽略不感兴趣的元素
import os
_,filename = os.path.split('/home/test/tuple.py')
print('filename:',filename)

(31.1111, 188.98763)
31.1111
188.98763
a: 100 b: 200
a: 200 b: 100
(2, 4)
(2, 4)
2 4
filename: tuple.py

# 用* 来处理剩下的元素
a,b,*rest = range(5)
print(a,b,rest)
a,b,*rest = range(3)
print(a,b,rest)
a,b,*rest = range(2)
print(a,b,rest)
a, *body,c,d = range(5)
print(a, body,c,d )

0 1 [2, 3, 4]
0 1 [2]
0 1 []
0 [1, 2] 3 4

嵌套元组拆包

嵌套元组的形式： (a, b, (c, d))
只要这个接受元组的嵌套结构符合表达式本身的嵌套结构，Python 就可以作出正确的对应.
对应嵌套的元组的拆包： a,b,(c,d) = (a, b, (c, d))

metro_areas = [ 
    ('Tokyo','JP',36.933,(35.689722,139.691667)),  
    ('Delhi NCR', 'IN', 21.935, (28.613889, 77.208889)), 
    ('Mexico City', 'MX', 20.142, (19.433333, -99.133333)), 
    ('New York-Newark', 'US', 20.104, (40.808611, -74.020386)), 
    ('Sao Paulo', 'BR', 19.649, (-23.547778, -46.635833)), 
] 

print('{:15} | {:^9} | {:^9}'.format('','lat','long'))
fmt = '{:15} | {:9.4f} | {:9.4f}'
# 符合元组的最后一个元素拆包到由变量构成的元组里
for name ,cc,pop,(lat,lng) in metro_areas:
    print(fmt.format(name,lat,lng))

                |    lat    |   long   
Tokyo           |   35.6897 |  139.6917
Delhi NCR       |   28.6139 |   77.2089
Mexico City     |   19.4333 |  -99.1333
New York-Newark |   40.8086 |  -74.0204
Sao Paulo       |  -23.5478 |  -46.6358

具名元组

需要给记录中的字段命名，namedtuple 函数。
构建带名字的元组和各个的元素的名字；
名元组需要两个参数：City = namedtuple('City','name country population coordinates')

第一个参数是元组的类名
第二个参数是元组的各个的元素的名字：空格分隔开的字段名组成的字符串

其实可以认为是一个新建了一个类，有类名和属性。
_fields 类属性
类方法 _make(iterable)
实例方法 _asdict()

from collections import namedtuple

City = namedtuple('City','name country population coordinates')
# 存放在对应字段里的数据要以一串参数的形式传入到构造函数中
sz = City('sz','China',15.236,(31.1234532,118.11223123))
print(sz)
#通过字段名或者位置来获取一个字段的信息
print(sz.coordinates)
print(sz.population)
print(sz[1])


##############具名元组还有一些自己专有的属性###########################
print(City._fields) #一个包含这个类所有字段名称的元组
LatLong = namedtuple('LatLong','lat Lng')
hk_tuple = ('HK','China',25.987,LatLong(31.976788,118.289393))
hk = City._make(hk_tuple) # _make() 通 过 接 受 一 个 可 迭 代 对 象 来 生 成 这 个 类 的 一 个 实 例
print(hk)
print(hk._asdict()) # _asdict() 把具名元组以 collections.OrderedDict 的形式返回

City(name='sz', country='China', population=15.236, coordinates=(31.1234532, 118.11223123))
(31.1234532, 118.11223123)
15.236
China
('name', 'country', 'population', 'coordinates')
City(name='HK', country='China', population=25.987, coordinates=LatLong(lat=31.976788, Lng=118.289393))
OrderedDict([('name', 'HK'), ('country', 'China'), ('population', 25.987), ('coordinates', LatLong(lat=31.976788, Lng=118.289393))])