python元组创建方式_Python的元组，没想象的那么简单

Python的元组与列表类似，元组一旦创建，元组中的数据一旦确立就不能改变，不能对元组中中的元素进行增删改操作，因此元组没有增加元素append、更新元素update、弹出元素pop等相关方法，只有简单的索引和计数的方法。

列表不能作为字典的key， 而元组可以；列表不能做为集合的项，而元组可以。列表是不可哈希unhashable的，列表元素可以被动态改变，所以没有一个固定不变的哈希值-这与集合要求的元素唯一性冲突；而元组的元素被禁止更新，其哈希值在整个生命周期都不会变化，因此可以成为集合的元素。

元组中可以包含任何数据类型，也可以包含另一个元组，如：T=(1,2,3，('a','b'))

空元组(没有元素的元组)：T=()，含1个元素的元组：T=(1，)，注意有逗号,多个元素的元组：T=(1,2,3)

一、元组的创建

可以用多种方式构建元组，主要有以下四种，每个都会有相应的案例：

使用一对圆括号来表示空元组: ()

使用一个后缀的逗号来表示单元组: a, 或 (a,)

使用以逗号分隔的多个项: a, b, c or (a, b, c)

使用内置的 tuple(): tuple() 或 tuple(iterable)

'''1、使用一对圆括号来表示空元组: ()'''

num_tuple = (1, 2, 3)

'''2、使用一个后缀的逗号来表示单元组: a, 或 (a,)'''

a = 'a',

a

('a',)

type(a)

tuple

'''3、使用以逗号分隔的多个项: a, b, c or (a, b, c)'''

t = 1,2,3

t

(1, 2, 3)

type(t)

tuple

t = 1,2,3,#结尾多一个逗号也没事，一样的效果

'''4、使用内置的 tuple(): tuple() 或 tuple(iterable)'''

t = (1, 2, 3)

t = tuple([1, 2

注意： 使用元组的时候，如果只有一个元素记得加上一个逗号，不然就是一条赋值语句。

#表达式 一个赋值语句

t = (1)

#用type查看下类型，是整数类型，并不是tuple类型

type(t)

int

t = (1,) #加逗号元组

二、元组的方法

由于元组并不能够像列表一样修改，因此元组并没有特别多的方法，就两个方法，count和index。

print(dir(tuple))

['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']

1、index

作用：tuple的index方法:获取指定元素的下标(就近原则，从左往右，找到第一个就结束)

用法：index(self, value, start=None, stop=None)

参数:value-待查询下标的元素

start-查询起始下标

stop-查询终止下标(查询到stop前一个下标)

t=('s','a','a','r',5)

t.index('r')

3

t.index(5)

4

# index方法：根据元素找到其位置

t = (1, 2, 3, 1, 2)

t.index(1, 2) # 寻找第2个元素1的位置

2、count

作用：获取指定元素在元组中出现的次数

用法：count(self, value)

参数：value-待查询出现次数的元素

t.count('a')

2

t.count(5)

1

3、其他操作

先生成两个元组备用

s1=(1,2,3)

s2=('a','b','c')

1)拼接生成新元组

'''拼接生成新元组'''

s1+s2

(1, 2, 3, 'a', 'b', 'c')

s1.__add__(s2)

(1, 2, 3, 'a', 'b', 'c')

2)是否包含

'''是否包含'''

2 in s1

True

s1.__contains__('a')

False

s2.__contains__('a')

Tru

3)获取元素

'''获取元素'''

s1[0]

1

s2.__getitem__(0)

'a'

4)获取长度

'''获取长度 '''

len(s1)

3

s1.__len__()

3

5)重复拼接

'''重复拼接'''

s1*3

(1, 2, 3, 1, 2, 3, 1, 2, 3)

6)删除元组

元祖中的元素值不可以修改和删除，但是我们可以使用 del 关键字删除整个元组。

t= ("a", "b", "c")

del t

t

name 't' is not defined

7)最大最小值

t= (10, 22, 0, 15, 40)

max(t)

40

min(t)

0

三、命名元组

对于元组，这个特性，我认为，才是元组存在的意义所在。只讲命名元组，可能不太好理解。如果称之为带字段名的记录，你可能就清楚了。

这里举个例子，但是实现带字段名，需要另一个库(collections)的支持，你需要导入它。

from collections import namedtuple

#生成一个City类

City = namedtuple("City", "name country polulation coordinates")

#实例化

tokyo = City("Tokyo", 'JP', '36.93', ('35.68','139,69'))

print(tokyo)

City(name='Tokyo', country='JP', polulation='36.93', coordinates=('35.68', '139,69'))

print(tokyo.name)

Toky

看着有点像字典，是不是，但是他不是字典(获取数值的方法也与字典不同)，字典是可变。元组在创建后，就无法再对其进行修改。这在某个程度上说明元组适合存放那些无需修改的数据。比如上面的，地名，国家，经纬度。

除了上面的用法之处，这里还要介绍一些元组自己专有的属性。

# 打印字段名

print(City._fields)

('name', 'country', 'polulation', 'coordinates')

# 生成新实例

LatLong = namedtuple('LatLong', 'lat long')

Xiamen_tuple = ('Xiemen', 'China', '40,54', LatLong(24.26,118.03))

Xiamen = City._make(Xiamen_tuple)

print(Xiamen)

City(name='Xiemen', country='China', polulation='40,54', coordinates=(24.26, 118.03))

# 将具名元组转为OrderDict

Xiamen_dict = Xiamen._asdict()

print(Xiamen_dict)

OrderedDict([('name', 'Xiemen'), ('country', 'China'), ('polulation', '40,54'), ('coordinates', LatLong(lat=24.26, long=118.03))

总结一下，元组是一种很强大的可以当作记录来用的数据类型，这才是他存在的价值和意义所在。而为人所熟知的，它的第二个角色才是充当一个不可变的列表。(以上都是个人看法，如有不同见解，欢迎留言讨论)

四、与列表的比较

类似的问题， 建议移步 StackOverflow 或者 python doc。

翻译部分观点如下：

1、Tuples are immutable, lists are mutable.

元组是不可变的， 而列表是可变的。

2、Tuples are heterogeneous data structures, lists are homogeneous sequences. Tuples have structure, lists have order.

元组通常由不同的数据，而列表是相同类型的数据队列。元组表示的是结构，而列表表示的是顺序。举个例子来讲：当你想记录棋盘上一个子的坐标时， 应该使用元组; 当你想记录棋盘上所有的子的坐标(一系列相同的数据)时，应该使用列表。

# 表示一个点

point = (1, 2)

# 表示一系列点

points = [(1, 2), (1, 3), (4, 5)]

3、 You can't use list as a dictionary identifier.

你不能将列表当作字典的key， 而元组可以。

a = (1, 2)

b = [4, 5]

c = {a: 'start point'} # OK {(1, 2): 'start point'}

c = {b: 'end point'} # Error

4、Due to the smaller size of a tuple operation with it a bit faster but not that much to mention about until you have a huge amount of elements.

由于元组支持的操作比列表小， 所以元组会比列表稍稍快上那么一丢丢。但是除非你有巨量的数据要去处理，否者这一点不需要特别强调。