Python中的列表（list），元组（Tuple），字典（Dict）和集合（Set)_综合

原文链接：https://blog.csdn.net/liuyanfeier/article/details/53731239
一，列表（list）
定义一个列表使用一对中(方)括号”[ ] “。

python内置的一种数据类型是列表：list是一种有序的数据集合，可以随意的添加和删除其中的数据。比如列出班里所有的同学的名字，列出所有工厂员工的工号等都是可以用到列表的。

不知道有没有人和我一样，刚刚接触列表对于说的这个有序不是很懂，不知道是什么有序。等我自己查资料的时候才知道，这个有序不是说list中的元素自己自动排好了序，而说的是这下面的这种情况：

>>> list1 = ['1','2','3']
>>> list2 = ['2','3','1']
>>> list1 == list2
False
>>> list1 is list2
False
>>> list3 = ['1','2','3']
>>> list1 == list3
True
>>> list1 is list3
False
>>>
  
  
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12

也就是说Python中是划分位置的，此为有序。

下面我们来看看Python中的列表的一些基本操作。
1.可以使用len()函数获得列表的长度（字典中的元素的个数）；
2.可以使用索引来引用列表中的元素，注意：列表中的索引是从０开始的，并且在列表中还支持负索引；
3.list是一个可以变的有序列表，因此可以往你自己的列表中添加和删除元素：在末尾添加元素用的是append()方法，在指定的位置插入元素使用的是insert()方法；
4.在列表中删除元素：删除末尾的元素使用的是pop()方法，删除指定位置的元素使用pop(i),其中i是索引下标；
5.若想替换list中的某个元素，可以直接把该元素赋值给对应的元素下标即可；
6.在一个list中可以有不同的数据类型，可以有字符串类型，整型，或者bool等，并且list的元素中也可以有另外一个list，就相当于一个循环的嵌套一样。

list的方法：

L.append(var)          #追加元素
L.insert(index,var)
L.pop(var)               #返回最后一个元素，并从list中删除之
L.remove(var)            #删除第一次出现的该元素
L.count(var)             #该元素在列表中出现的个数
L.index(var)             #该元素的位置,无则抛异常
L.extend(list6)         #追加list６，即合并list到L上,这里注意，使用extend函数可以一次在一个列表中插入任意多个值，而不必须每次只使用append()一次一值的插入
L.sort()        #排序
L.reverse()     #倒序
del L[1]        #删除指定下标的元素
del L[1:3]      #删除指定下标范围的元素#复制list:
L1 = L      #L1为L的别名，用C来说就是指针地址相同，对L1操作即对L操作。
L1 = L[:]   #L1为L的克隆，即另一个拷贝。
  
  
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15

list1 = ['you', 'me', 'her', 'he', 1000, 100000.123]print list1
print len(list1)
print list1[1],list1[-1]list1.append('it']
list1.insert(3,'30')
print list1list1.pop()
list1.pop(1)
print list1list1[2] = 'hello'
print list1list2 = ['wang','wu','luo',['lang','luo','zhang'],'kua']
print list2
print list2[3][1]list1.extend(list2)
print list1
  
  
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23

输出：

['you', 'me', 'her', 'he', 1000, 100000.123]
6
me 100000.123
['you', 'me', 'her', '30', 'he', 1000, 100000.123, 'it']
['you', 'her', '30', 'he', 1000, 100000.123]
['you', 'her', 'hello', 'he', 1000, 100000.123]
['wang', 'wu', 'luo', ['lang', 'luo', 'zhang'], 'kua']
luo
['you', 'her', 'hello', 'he', 1000, 100000.123, 'wang', 'wu', 'luo', ['lang', 'luo', 'zhang'], 'kua']
  
  
   1
   2
   3
   4
   5
   6
   7
   8
   9

二，元组（Tuple）
定义一个元组使用一对小(圆)括号”( ) “。

和列表类似，元组也是一种有序列表，虽然tuple和list非常之类似，但是list初始化之后使可以改变的，但是，元组一旦初始化之后就不可以改变。这点与Python中的字符串类似，所以我们说元组和字符串都是不可变的序列。

现在tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用tuple[0]，tuple[-1]，但不能赋值成另外的元素。
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple的陷阱：
1.当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来；
2.定义只有一个元素的Tuple的时候，需要这样:
tuple1 = (123,)
后面要加上一个逗号，这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义。
tuple2 = (123) ＃如果你这样定义你定义的将是１２３这个元素，而不是一个元组。
python在显示只有1个元素的tuple时，也会加一个逗号,，以免你误解成数学计算意义上的括号。

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合：

>>> t1 = ('wuyanl','luoting','aimeiyu')
>>> t2 = (1,2,3,4,5,6,7,8,9,0)
>>> t1 ('wuyanl', 'luoting', 'aimeiyu')
>>> t2
(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
>>> t3 = t1 +t2
>>> t3
('wuyanl', 'luoting', 'aimeiyu', 1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
>>>
  
  
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组。

元组的内置函数：
1.比较两个元组元素：cmp(tuple1,tuple2)相等的话返回0，不相等返回1；
2.计算元组的长度：len(tuple
3.返回元组中的最大值最小值：max(tuple),min(tuple)；
4.将列表转换成元组：Tuple = tuple(list)。

三，字典（Dict）
定义 Dictionary 使用一对大(花)括号” { } ”。
字典(Dictionary) 是 Python 的内置数据类型之一，它定义了键和值之间一对一的关系,但它们是以无序的方式储存的。字典中的“值”通过键来引用。

与列表区别：字典是无序的，在字典中通过键来访问成员。
字典是可变的，可以包含任何其他类型

声明:
M={k1:v1,k2:v2}
访问 M[k1]将得到v1

常用字典操作：
dic.clear()清空字典
dic.keys()获得键的列表
dic.values()获得值的列表
dic.copy()复制字典
dic.pop(k)删除键k
dic.get(k)获得键k的值
dic.update()更新成员，若成员不存在，相当于加入
dic.items()获得由键和值组成的列表

get()语法：
dict.get(key, default=None)
参数
key – 字典中要查找的键。
default – 如果指定键的值不存在时，返回该默认值值。
返回值
返回指定键的值，如果值不在字典中返回默认值None。

#字典操作 
m = {
   'a':1,'b':2,'c':3}  
print(m)  
#读取某一个_通过key 
print(m['a'])  
#读取某一个，通过get方法 
print(m.get('b'))  
#复制字典 
m2 = m.copy()  
print(m2)  
#获取所有键的列表 
print( m.keys() )  
#获取所有值的列表 
print( m.values() )  
#获取所有键值对元组组成的列表 
print( m.items() )  
#更新成员，当对应键值不存在时，相当于加入 
m.update({
   'd':4})  
print(m)  
#删除某个成员 
m.pop('a')  
print(m)  
#遍历
from key in m.keys():if(key=='x'):del m[key]
  
  
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26

四，集合（Set）
Python的集合(set)和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素.

#定义一个集合
set1 = {
   1, 2, 3, 4, 5}
# 或者使用 set 函数
list1 = [6, 7, 7, 8, 8, 9]
set2 = set(list1)
set2.add(10) # 添加新元素
print set2 # set([8, 9, 6, 7]) 去掉重复内容,而且是无序的
set3 = frozenset(list1)    #固定集合
set3.add(10) # 固定集合不能添加元素
#方法（所有的集合方法）：
s.issubset(t) #如果s是t的子集,返回True，否则返回False
s.issuperset(t) #如果s是t的超集,返回True，否则返回False
s.union(t) #返回一个新集合, 该集合是s和t的并集
s.intersection(t) #返回一个新集合, 该集合是s和t的交集
s.difference(t) #返回一个新集合, 该集合是s的成员, 但不是t的成员, 即返回s不同于t的元素
s.symmetric_defference(t) #返回所有s和t独有的(非共同拥有)元素集合
s.copy() #返回一个s的浅拷贝, 效率比工厂要好
#方法（仅适用于可变集合）:以下方法参数必须是可哈希的
s.update(t) #用t中的元素 修改s，即s现在包含s或t的成员
s.intersection_update(t) #s中的成员是共同属于s和t的元素
s.difference_update(t) #s中的成员是属于s但不包含在t中的元素
s.symmetric_difference_update(t) #s中的成员更新为那些包含在s或t中，但不是s和t共有的元素
s.add(obj) #在集合s中添加对象obj
s.remove(obj) #从集合s中删除对象obj，如果obj不是集合s中的元素（obj not in s）,将引发keyError错误
s.discard(obj) #如果obj是集合s中的元素，从集合s中删除对象obj
s.pop() #删除集合s中得任意一个对象，并返回它
s.clear() #删除集合s中的所有元素
## 集合有并集，交集，求差操作
## 并集：intersection() 方法返回一个新集合，包含在两个集合中同时出现的所有元素。
## 交集：union() 方法返回一个新集合，包含在两个 集合中出现的元素。
## 差集：difference() 方法返回的新集合中，包含所有在 集合A出现但未在集合B中的元素。
## symmetric_difference() 方法返回一个新集合，包含所有只在其中一个集合中出现的元素。
# 删除元素
set2.discard(6) # 当元素不存在时,不会引发异常
set2.remove(6) # 与discard的区别在于，如果没有要删除的元素，remove会引发一个异常
set2.pop() # 因为set是无序的，所以pop会随机的从set中删除一个元素
  
  
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36