分析Python中List、Tuple、字典、Set的区别和用法

淡淡的烟草味﹌ 2022-12-01 05:11 248阅读 0赞

## 列表(List) ##

**列表的特点**  
1.用来储存多个数据的数据结构  
2.储存的数据是有序的，可使用位置索引  
3.列表长度和元素都是可变的  
4.可储存不同类型的数据  
序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。  
Python有6个序列的内置类型，但最常见的是列表和元组。  
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。  
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

a = [1, 'abc', 12.12,3,4,5,6]

可以看到并不要求元素的类型都是一样的。当然也可以定义一个空的List:

b = []

Python中的List是有序的，所以要访问List的话显然要通过序号来访问，就像是数组的下标一样，一样是下标从0开始,也可以使用方括号的形式截取字符：

a [0]
    a [1:5]

List也可以倒序访问，通过“倒数第x个”这样的下标来表示序号，比如-1这个下标就表示倒数第一个元素：

print a[-1]
    >> 6

List通过内置的**append**()方法来添加到尾部，通过**insert**()方法添加到指定位置（下标从0开始）：

a = [1, 'abc', 12.12,3]
    a.append('Jack')
    print a
    [ 1, 'abc', 12.12,3,'Jack']
    
    a.insert(1, 3.14)
    print a
    [ 1,3.14, 'abc', 12.12,3,'Jack']

通过**pop**()删除最后尾部元素，也可以指定一参数删除指定位置：

a = [1, 'abc', 12.12,3]
    a.pop()
    print a
    [ 1, 'abc', 12.12]
    
    a = [1, 'abc', 12.12,3]
    a.pop(0)
    print a
    [ 'abc', 12.12,3]

可以使用 **del**语句来删除列表的元素，如下实例：

list1 = [1,2,3,4,5]
    del list1[2]
    print list1
    [1,2,4,5]

## 元组（Tuple） ##

Python的元组与列表类似，不同之处在于元组的元素不能修改,长度不可改变,常用于安全级别较高的场景应用。  
元组使用小括号（），列表使用方括号\[ \]。  
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。  
Tuple可以看做是一种“不变”的List，访问也是通过下标，用小括号（）表示：

tup1 = ('physics', 'chemistry', 1997, 2000)
    tup2 = (1, 2, 3, 4, 5 )
    tup3 = "a", "b", "c", "d"

创建空元组

tup1 = ()

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

tup1 = (1,)

元组与字符串类似，下标索引从0开始，可以进行截取，组合等,但是没有pop和insert、append方法。  
那么tuple这个类型到底有什么用处呢？

要知道如果你希望一个函数返回多个返回值，其实只要返回一个tuple就可以了，因为tuple里面的含有多个值，而且是不可变的（就像是java里面的final）。当然，tuple也是可变的，比如:

t  = (3.14, 'China', 'Jason', ['A', 'B'])
    a = t[3]
    a[0] = 12
    a[1]= 13
    print t
    (3.14, 'China', 'Jason', [12, 13])

这是因为Tuple所谓的不可变指的是指向的位置不可变，因为本例子中第四个元素并不是基本类型，而是一个List类型，所以t指向的该List的位置是不变的，但是List本身的内容是可以变化的，因为List本身在内存中的分配并不是连续的。

#### 元组运算符 ####

与字符串一样，元组之间可以使用 + 号和 \* 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

*  **len()**  
    计算元素个数：len((1, 2, 3))结果是3
 *  **+**  
    合并两个元组： (1, 2, 3) + (4, 5, 6)，结果是(1,2,3,4,5,6)
 *  \***n**  
    元素复制n次：(‘Hi!’,) \* 4，结果是(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’)
 *  **in**  
    元素是否存在元组中，有就返回ture：3 in (1, 2, 3)，结果是True
 *  **for x in (1, 2, 3):**  
    迭代 :for x in (1, 2, 3)：print x,结果是1 2 3

## 字典（Dict） ##

Dict是Python中非常重要的数据类型，就像它的字面意思一样，它是个活字典，其实就是Key-Value键值对，类似于HashMap，可以用花括号\{\}通过类似于定义一个C语言的结构体那样去定义它：

d = { key1 : value1, key2 : value2 }

键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

dict = { 'a': 1, 'b': 2, 'b': '3'}
    dict['b']
    // 3
    dict
    // {'a': 1, 'b': '3'}

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。  
创建字典：

dict1 = { 'abc': 456}
    dict2 = { 'abc': 123, 'def': 567}

可以直接通过键值对方式添加dict中的元素：

a = { 'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Bart': 59}
    a['Jone'] = 99
    print a
    { 'Lisa': 85, 'Paul': 75, 'Adam': 95, 'Jone': 99, 'Bart': 59}

List和Tuple用下标来访问内容，而Dict用Key来访问： (字符串、整型、浮点型和元组tuple都可以作为dict的key):

print a['Adam']
    95

如果Key不存在，会报错：  
所以访问之前最好先查询下key是否存在：

if 'Adam' in a :   
        print 'exist key'
    // exist key

或者直接用保险的get方法：

print d.get('Adam')
    95

至于遍历一个dict，实际上是在遍历它的所有的Key的集合，然后用这个Key来获得对应的Value:

for key in a : print key, ':', a.get(key)
    
    Lisa : 85
    Paul : 75
    Adam : 95
    Bart : 59

#### 修改字典 ####

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

dict = { 'Name': 'Zara', 'Age': 7, 'Class': 'First'}
    
    dict['Age'] = 8 # 更新
    dict['School'] = "RUNOOB" # 添加
    
    print "dict['Age']: ", dict['Age']
    print "dict['School']: ", dict['School']
    
    结果：
    dict['Age']:  8
    dict['School']:  RUNOOB

#### 删除字典元素 ####

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

dict = { 'Name': 'Zara', 'Age': 7, 'Class': 'First'}
    
    del dict['Name']  # 删除键是'Name'的条目
    dict.clear()      # 清空字典所有条目
    del dict          # 删除字典
    
    print "dict['Age']: ", dict['Age'] 
    print "dict['School']: ", dict['School']

但这会引发一个异常，因为用del后字典不再存在：

dict['Age']:
    Traceback (most recent call last):
      File "test.py", line 8, in <module>
        print "dict['Age']: ", dict['Age'] 
    TypeError: 'type' object is unsubscriptable

#### 字典键的特性 ####

字典值可以没有限制地取任何python对象，既可以是标准的对象，也可以是用户定义的，但键不行。  
两个重要的点需要记住：

1.  不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会覆盖前一个值，如下实例：

dict = { 'Name': 'Zara', 'Age': 7, 'Name': 'Manni'} 
    print "dict['Name']: ", dict['Name']
    
    dict['Name']:  Manni

1.  键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行，如下实例：

dict = { ['Name']: 'Zara', 'Age': 7} 
    print "dict['Name']: ", dict['Name']

结果就会报错：

Traceback (most recent call last):
      File "test.py", line 3, in <module>
        dict = { ['Name']: 'Zara', 'Age': 7} 
    TypeError: list objects are unhashable

**合并两个字典**  
如何将两个Dict合并为一个，可以用**dict函数**：

d1 = { 'mike':12, 'jack':19}
    d2 = { 'jone':22, 'ivy':17}
    d3 = dict(d1.items() + d2.items())
    print d3
    
    { 'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

或者

d4 = dict(d1, **d2)
    print d4
    
    { 'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

后一个方法比前一个方法速度快很多，方法2等同于：

d3 = dict(d1)
    d3.update(d2)
    print d3
    
    { 'mike': 12, 'jack': 19, 'jone': 22, 'ivy': 17}

### 字典包含了以下内置方法： ###

*  **dict.clear()**  
    删除字典内所有元素
 *  **dict.copy()**  
    返回一个字典的浅复制
 *  **dict.fromkeys(seq\[, val\])**  
    创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
 *  **dict.get(key, default=None)**  
    返回指定键的值，如果值不在字典中返回default值
 *  **dict.has\_key(key)**  
    如果键在字典dict里返回true，否则返回false
 *  **dict.items()**  
    以列表返回可遍历的(键, 值) 元组数组
 *  **dict.keys()**  
    以列表返回一个字典所有的键
 *  **dict.setdefault(key, default=None)**  
    和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
 *  **dict.update(dict2)**  
    把字典dict2的键/值对更新到dict里
 *  **dict.values()**  
    以列表返回字典中的所有值
 *  **pop(key\[,default\])**  
    删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。  
    否则，返回default值。
 *  **popitem()**  
    返回并删除字典中的最后一对键和值。

**Dict具有的特点**：

*  查找速度快。无论是10个还是10万个，速度都是一样的，但是代价是耗费的内存大。List相反，占用内存小，但是查找速度慢。这就好比是数组和链表的区别，数组并不知道要开辟多少空间，所以往往开始就会开辟一个大空间，但是直接通过下标查找速度快；而链表占用的空间小，但是查找的时候必须顺序的遍历导致速度很慢。
 *  没有顺序。Dict是无顺序的，而List是有序的集合，所以不能用Dict来存储有序集合
 *  Key不可变，Value可变。一旦一个键值对加入dict后，它对应的key就不能再变了，但是Value是可以变化的。所以List不可以当做Dict的Key，但是可以作为Value。

## Set（集合） ##

储存形式与列表相似：  
1.集合中保存的数据具有唯一性，不可重复  
2.集合中保存的数据是无序的  
3.往集合中添加重复数据，集合将只保留一个  
集合常被用来去重或者过滤  
set就像是把Dict中的key抽出来了一样，类似于一个List，但是内容又不能重复，通过调用set()方法创建：

s = set(['A', 'B', 'C'])

就像dict是无序的一样，set也是无序的，也不能包含重复的元素。  
对于访问一个set的意义就仅仅在于查看某个元素是否在这个集合里面：

print 'A' in s
    True
    
    print 'D' in s
    False

也通过for来遍历：

s = set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])
    
    for x in s:
        print x[0],':',x[1]
    
    
    Lisa : 85
    Adam : 95
    Bart : 59

**通过add和remove来添加、删除元素（保持不重复），添加元素时，用set的add()方法**：

#### 添加元素用add()方法 ####

s = set([1, 2, 3])
    s.add(4)
    print s
    
    set([1, 2, 3, 4])

如果添加的元素已经存在于set中，add()不会报错，但是不会加进去了：

s = set([1, 2, 3])
    s.add(3)
    print s
    
    set([1, 2, 3])

#### 删除元素用remove()方法 ####

s = set([1, 2, 3, 4])
    s.remove(4)
    print s
    
    set([1, 2, 3])

如果删除的元素不存在set中，remove()会报错：

s = set([1, 2, 3])
    s.remove(4)
    
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    KeyError: 4

所以如果我们要判断一个元素是否在一些不同的条件内符合，用set是最好的选择，举例说明：

months = set(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'])
    x1 = 'Feb'
    x2 = 'Sun'
    
    if x1 in months:
        print 'x1: ok'
    else:
        print 'x1: error'
    
    if x2 in months:
        print 'x2: ok'
    else:
        print 'x2: error'
    
    
    x1: ok
    x2: error

#### 集合的应用 ####

s1 = { 1,2,3}，s2 = { 3,4,5}，s3 = { 3,1,6}
    
    集合的并集
    newSet = s1 | s2 | s3
    或
    newSet = s1.union(s2, s3)
    
    集合的交集
    newSet = s1 & s2 & s3
    或
    newSet = s1.intersection(s2, s3)
    
    集合的差集
    newSet = s1 - s2 - s3
    或
    newSet = s1.difference(s2, s3)
    
    判断是否是超集
    s1.issuperset(s2)
    
    判断是否是子集
    s2.issubset(s1)
    
    判断两个集合是否相交
    s1.isdisjoint(s2)

**注意：**  
集合的遍历与列表的遍历方法相同

Python中List、Tuple、字典、Set的区别和用法就说到这里，以后还会补充Python其它的基础只是给大家，记得关注小编！