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

我会带着你远行 2022-07-13 01:26 200阅读 0赞

一，列表（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
    >>>

也就是说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的克隆，即另一个拷贝。

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 list1
    
    list1.pop()
    list1.pop(1)
    print list1
    
    list1[2] = 'hello'
    print list1
    
    list2 = ['wang','wu','luo',['lang','luo','zhang'],'kua']
    print list2
    print list2[3][1]
    
    list1.extend(list2)
    print list1

输出：

['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']

二，元组（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)
    >>>

元组中的元素值是不允许删除的，但我们可以使用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]

四，集合（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中删除一个元素