克隆策略

创建空元组

In [1]:
tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号

In [2]:
tup1 = (50,)
tup1
Out[2]:
(50,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等。元组可以使用下标索引来访问元组中的值，如下实例：

In [3]:
tup1 = ('physics', 'chemistry', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )

print("tup1[0]: ", tup1[0])
print("tup2[1:5]: ", tup2[1:5])

tup1[0]:  physics
tup2[1:5]:  (2, 3, 4, 5)

修改元组

元组与列表不同，元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例：

In [4]:
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')

# 以下修改元组元素操作是非法的,会出现TypeError错误。
tup1[0] = 100;

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-e008270ca851> in <module>()
      3 
      4 # 以下修改元组元素操作是非法的,会出现TypeError错误。
----> 5 tup1[0] = 100;

TypeError: 'tuple' object does not support item assignment
In [ ]:
# 创建一个新的元组
tup3 = tup1 + tup2
print(tup3)

删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，实例中元组被删除后，输出变量会有异常信息，如下实例:

In [ ]:
tup = ('physics', 'chemistry', 1997, 2000)
print(tup)
In [ ]:
del tup
print(tup)

任意无符号的对象，以逗号隔开，默认为元组，如下实例：

In [ ]:
print('abc', -4.24e93, 18+6.6j, 'xyz')
x, y = 1, 2
print("Value of x , y : ", x,y)

Python 的元组数据类型包含更多的方法。

tup.index(x, [start, [stop]])) 返回元组中start到stop索引中第一个值为 x 的元素在整个列表中的索引。如果没有匹配的元素就会返回一个错误。

tup.count(x) 返回 x 在元组中出现的次数。

cmp(tuple1, tuple2) 比较元组中两个元素。

len(tuple) 计算元组元素个数。

max(tuple) 返回元组中元素最大值。

min(tuple) 返回元组中元素最小值。

tuple(seq) 将列表转换为元组。

元组不提供字符串、列表和字典中的方法。如果相对元组排序，通常先得将它转换为列表并使其成为一个可变对象，才能获得使用排序方法，或使用sorted内置方法。

In [ ]:
T = ('c','a','d','e')
tmp = list(T)
tmp.sort()
print(tmp)
print(tuple(tmp))
In [ ]:
T = ('c','a','d','e')
sorted(T) # 按字母顺序排序

列表解析也可用于元组的转换

In [ ]:
T = (1,2,3,4,5)
L = [x+20 for x in T]
L
In [ ]:
T = (1,2,3,2,3,5,2)
print(T.index(2))
print(T.index(5,2,7))
print(T.count(2))

集合

Python 还包含一种数据类型 set (集合)。集合是一个无序不重复元素的集。基本功能包括关系运算和消除重复元素。比如支持 union(联合)，intersection(交)，difference(差)和 sysmmetric difference(对称差集)等数学关系运算。

大括号或 set() 函数可以用来创建集合。注：创建空集合，你必须使用 set() 而不是 {}，后者用于创建空字典

所有集合方法

S.issubset(t) 如果 s 是 t 的子集，则返回True，否则返回False

S.issuperset(t) 如果 s 是 t 的超集，则返回True，否则返回False

S.unoin(t) 返回一个新集合，该集合是s和t的并集，也可用s1|s2，但不能用s1+s2

S.intersection(t)返回一个新集合，该集合是s和t的交集,，也可用s1&s2

S.difference(t) 返回一个新集合，该集合是s的成员，但不是t的成员,，也可用s1-s2

S.symmetric_difference(t)对称差分是集合的异或，返回一个新集合，该集合是s或t的成员，但不是s和t共有的成员，也可用s1^s2

S.copy()返回一个新集合，该集合是s的复制

仅适合可变集合

S.update(t) 用t中的元素修改s，即s现在包括s或t的成员

S.intersection_update s中的成员是共同属于s和t的元素

S.difference_update s中的成员是属于s但不包含在t中的元素

S.symmetric_difference_update s中的成员更新为那些包含在s或t中，但不是s和t共有的元素

S.add(obj) 在集合s中添加对象obj

S.remove(obj) 从集合s中删除对象obj，如果obj不是集合s中的元素将有错误

S.discard(obj) 如果obj是集合s中的元素，从集合s中删除对象obj

S.pop() 删除集合s中的任意一个对象，并返回它

S.clear() 删除集合s中的所有元素

In [ ]:
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
fruit = set(basket)
print(fruit)
print('orange' in fruit)
print('crabgrass' in fruit)
In [ ]:
a = set('abracadabra')
b = set('alacazam')
print('a:\t',a)                                  # 唯一值
print('a - b:\t',a - b)                              # 在a不在b里面
print('a | b:\t',a | b)                             # 在a或b里
print('a & b:\t',a & b)                             # a、b里面都有
print('a ^ b:\t',a ^ b)                              # 在a或b里但是不同时在两个里面
print('a>b,a<b:\t',a>b,a<b)

集合推导式语法

In [ ]:
a = {x for x in 'abracadabra' if x not in 'abc'}#'abc'默认是集合
a
In [ ]:
basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
fruit = set(basket)
print(fruit)

列表和字典不能嵌入到集合中，但是元组是可以嵌入的

In [ ]:
S = set()
S.add([1,2,3])
In [ ]:
S.add((1,2,3))
S
In [ ]:
type(S)