Python中不可变的元组_不可变组合 元祖代码

元组的创建

• 元组是关系数据库中的基本概念，关系是一张表，表中的每一行就是一个元组，每列就是一个属性。

• 元组被称为带了紧箍咒的列表，因为列表是可变的，元组是不可变的。

• 创建时只需在括号中添加元素，并用逗号分离，或者直接用逗号分隔；

In [6]: 1,2,3
Out[6]: (1, 2, 3)

In [7]: (1,2,3)
Out[7]: (1, 2, 3)

1
2
3
4
5
6

创建一个空元组

In [12]: t=()

In [13]: t , type(t)
Out[13]: ((), tuple)

1
2
3
4
5

元组中只有一个元素时，需要在元素后添加逗号，否则括号会被当成运算符使用

In [8]: t=(1)

In [9]: type(t)
Out[9]: int

In [10]: t=(1,)

In [11]: type(t)
Out[11]: tuple

In [14]: 3*(40+2)
Out[14]: 126

In [15]: 3*(40+2,)
Out[15]: (42, 42, 42)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

元组的嵌套

元组中可以嵌套数值，字符串，列表，元组等。

t6 = (1, 1.7, 1L, "hello", True, 1+3j, [1,2,3,4], (1,2,3))
# print t6, type(t6)
1
2

元组的特性

# 索引
print t6[0], t6[-1]
# 索引里面的索引
print t6[-1][0]
1
2
3
4

# 切片
print t6[::-1] # 反转元组
print t6[1:]    # 去掉元组的第一个元素
1
2
3

# 重复
print t6 * 3
1
2

# 连接
print  (1,2,3) + (1,3,4)

1
2
3

成员操作符

print 'hello' in t6
print 'hello' not in t6
print "OK" if 'hello' in t6 else  "not ok"

1
2
3
4
5

a判断元组是否为空

stack = []
# if后面跟bool类型;
# bool(stack) :
#           stack = [], False
#           stack = [1,2,3]  True
# 如果stack列表中有值， 执行的内容;
# if stack:
if stack != []:
    print "have item"
else:
    print "no item"
1
2
3
4
5
6
7
8
9
10
11

元组使用方法

• 元组是不可变数据类型，不能对元组进行添加或修改，也不能删除元组中的元素，除非删除整个元组在内存占的位置。
• 元组是可迭代数据类型

t = (1,2,3,1,2,3)
for i in t:
    print i
1
2
3

# value值出现的次数;
print t.count(1) # 2

# value值的索引,遇到的第一个元素的索引
print t.index(2)  # 1

1
2
3
4
5
6

内置方法

cmp（（1，2，3），（1，2，3，4））
1

• 如果两个元组相等且元素相等则返回0
• 如果第一个小则返回-1
• 如果第一个大则返回1

zip函数

将列表中的元素依次取出，，然后组合，如果元素长度不一样则会被砍到一样，
zip（*list）是上一个操作的逆操作

hosts = ['172.25.254.1', '172.25.254.2','172.25.254.3','172.25.254.4']
ports = [22, 80, 3306, 21]
print zip(hosts, ports)
1
2
3

枚举类型

# 枚举enumerate， 每一个i是一个元组，(索引值， 元组元素)
for i,j in enumerate(hosts):
    print i,j
1
2
3

元组应用场景

print "%s:%s:%d" %('hello', 'world', 3306)

1
2

变量交换

x = 1
y = 2
x,y = y,x
1
2
3

1. 先开辟一片内存空间， 存储元组， 元组内容(y,x) (2,1)
2. x,y = (2,1)
3. x = (2,1)[0]
4. y = (2,1)[1]