接着上一篇继续统计各个数据类型常用的方法，本篇将展现元组、字典、集合三种数据类型。
希望大家多多支持(点赞、转发、关注)

元组(tuple)相关的方法(操作)

相比其他类型来说，归属元组的方法就很少了，大都属于通用型了，例如：

访问元组

# 通过下标的方式访问元组内部的某个元素
tup = ("python", "java", "go", "php")
print(tup[1])
>>> java
# 通过下标来截取多个元素
print(tup[1:2])
>>> ("java", "go")

元组内置函数

字典(dict)相关的方法

字典是另一种可变容器模型，且可存储任意类型对象（key: value的形式）

clear()

移除字典中的所有元素

dict = {"1": "python", "2": "java", "3": "go"}
print(dict.clear())
>>> None

copy()

返回原字典的浅拷贝

dict = {"1": "python", "2": "java", "3": "go"}
dict_copy = dict.copy()
print(dict_copy)
>>> {"1": "python", "2": "java", "3": "go"}

formkeys(iterable[, value])

属于类方法，会返回一个新字典

• iterable -- 字典键序列
• value -- 可选参数, 设置键序列（iterable）的值

seq = ("python", "java", "go", "php")
dict1 = dict.fromkeys(seq)
dict2 = dict.fromkeys(seq, 1)
print(dict1)
print(dict2)
>>> {'python': None, 'java': None, 'go': None, 'php': None}
>>> {'python': 1, 'java': 1, 'go': 1, 'php': 1}

get(key[, default])

如果 key 存在于字典中则返回 key 的值，否则返回 default。 如果 default 未给出则默认为 None，因而此方法绝不会引发 KeyError

• key -- 字典中要查找的键
• default -- 如果指定键的值不存在时，返回该默认值

dict = {"1": "python", "2": "java", "3": "go"}
print(dict.get("1"))
print(dict.get("0", "请输入正确的KEY值"))
>>> "python"
>>> "请输入正确的KEY值"

items()

以列表包含元组的形势返回可遍历的(键, 值) ，每个元组就一对key: value

dict = {"1": "python", "2": "java", "3": "go"}
for key,values in  dict.items():
    print key,values   
>>> 1 python
>>> 2 java
>>> 3 go

keys()

以列表形式返回一个字典所有的键

dict = {"1": "python", "2": "java", "3": "go"}
for key in dict.keys():
    print(key)
>>> 1
>>> 2
>>> 3

pop(key[, default])

如果 key 存在于字典中则将其移除并返回其值，否则返回 default。 如果 default 未给出且 key 不存在于字典中，则会引发 KeyError

• key -- 字典中要删除的键
• default -- 如果指定键的值不存在时，返回该默认值

dict = {"1": "python", "2": "java", "3": "go"}
print(d.pop("1"))
print(d.pop("0", "key值不存在"))
>>> python
>>> key值不存在

popitem()

从字典中移除并返回一个 (键, 值) 对键值对会按 后进先出 的顺序被返回
适用于对字典进行消耗性的迭代，这在集合算法中经常被使用。 如果字典为空，调用 popitem()将引发 KeyError

dict = {"1": "python", "3": "go"}
print(dict.popitem())
print(dict.popitem())
print(dict.popitem())
>>> ('3', 'go')
>>> ('1', 'python')
>>> KeyError: 'popitem(): dictionary is empty'

setdefault(key[, default])

如果字典存在键 key ，返回它的值。如果不存在，插入值为 default 的键 key ，并返回 default 。 default 默认为 None

• key -- 查找的键值。
• default -- 键不存在时，设置的默认键值。

dict = {"1": "python", "3": "go"}
print(dict.setdefault("1", None))
print(dict.setdefault("0", "测试"))
print(dict)
>>> python
>>> 测试
>>> {'1': 'python', '2': 'java', '3': 'go', '0': '测试'}

update([other])

使用来自 other 的键/值对更新字典，覆盖原有的键。 返回 None
update() 接受另一个字典对象，或者一个包含键/值对（以长度为二的元组或其他可迭代对象表示）的可迭代对象。 如果给出了关键字参数，则会以其所指定的键/值对更新字典: d.update(red=1, blue=2)

• other -- 添加到指定字典dict里的键/值对

dict = {"1": "python", "2": "java", "3": "go"}
dict.update({"4": "php"})
dict.update(red=1, blue=2, green=3)
print(dict)
>>> {'1': 'python', '2': 'java', '3': 'go', '4': 'php', 'red': 1, 'blue': 2, 'green': 3}

values()

以列表形式返回字典中的所有值

dict = {"1": "python", "2": "java", "3": "go"}
print(d.values())
>>> ['python', 'java', 'go']

集合(set)相关的方法

add(elem)

将元素 elem 添加到集合中

• elem -- 将要添加的元素

set = {"python", "java"}
set.add("go")
set.add("python")       # 集合中已有的元素不会重复添加(去重)
print(set)
>>> {'java', 'python', 'go'}

remove(elem)

从集合中移除元素 elem。 如果 elem 不存在于集合中则会引发 KeyError

• elem -- 将要移除的元素

set = {"python", "java"}
set.remove("python")
set.remove("go")
print(set)
>>> {'java'}
>>> KeyError: 'go'

discard(elem)

如果元素 elem 存在于集合中则将其移除

• 将要移除的元素

set = {"python", "java"}
set.discard("python")
set.discard("go")
print(set)
>>> {'java'}

pop()

从集合中移除并返回任意一个元素。 如果集合为空则会引发 KeyError

set = {"python"}
set.pop()
print(set)
>>> set()
set.pop()
print(set)
>>> KeyError: 'pop from an empty set'

clear()

从集合中移除所有元素。

set = {"python", "java"}
set.clear()
print(set)
>>> set()

difference(*others)

返回一个新集合，其中包含原集合中，在 others 指定的其他集合中不存在的元素

set1 = {"python", "java"}
set2 = {"python", "php", "go"}
set3 = set1.difference(set2)
print(set3)
>>> {'java'}

intersection(*others)

返回一个新集合，其中包含原集合以及 others 指定的所有集合中共有的元素

• othera -- 要查找相同元素的集合

set1 = {"python", "java"}
set2 = {"python", "php", "go"}
set3 = set1.intersection(set2)
print(set3)
>>> {'python'}

isdisjoint(other)

判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False

• other -- 要比较的集合

set1 = {"python", "java"}
set2 = {"python", "php", "go"}
set3 = {"php", "go"}
print(set1.isdisjoint(set2))
print(set1.isdisjoint(set3))
>>> False
>>> True

issubset(other)

判断指定集合是否为该方法参数集合的子集

• other -- 要比查找的集合

set1 = {"python", "java"}
set2 = {"python", "php", "go", "java"}
set3 = {"python", "php", "go"}
print(set1.issubset(set2))
print(set1.issubset(set3))
>>> True
>>> False

issuperset(other)

用于判断指定集合的所有元素是否都包含在原始的集合中，如果是则返回 True，否则返回 False

• other -- 要比查找的集合

set1 = {"python", "php", "go", "java"}
set2 = {"python", "c++"}
set3 = {"python", "php", "go"}
print(set1.issubset(set2))
print(set1.issubset(set3))
>>> False
>>> True

update(*others)

更新集合，添加来自 others 中的所有元素

• other -- 可以是元素或集合

set1 = {"python", "php", "go", "java"}
set2 = {"python", "c++"}
set1.update(set2)
print(set1)
>>> {'c++', 'python', 'java', 'php', 'go'}

union(*others)

方法返回两个集合的并集，即包含了所有集合的元素，重复的元素只会出现一次

• other -- 合并的目标集合

set1 = {"python", "php", "go", "java"}
set2 = {"python", "c++"}
set3 = {"python", "php", "go"}
result = set1.union(set2, set3)
print(result)
>>> {'c#', 'python', 'c++', 'java', 'go', 'php'}

至此，python数据类型的常用方法已经统计完毕。