Tools

python（三）列表元组字典集合（list tuple dict set）

阅读：722 发布：2018-04-08 作者：lypeng

# list列表（序列）
list是一种有序的集合，可以随时添加和删除其中的元素，元素可以重复
## 序列定义
x = ['1','2','3','4','5'];
x = [1,2,3,4,5]
x = ['字符串',[2,2,2,3],3,4,5] //可以嵌套list

## 序列调用
x[下标]
x[起始位置:结束位置]
x[起始位置:结束位置:递增值]

x=[0,1,2,3,4,5,6,7,8,9]
x[0]    =   0
x[3:]   =   [3,4,5,6,7,8,9]
x[1:3]  =   [1,2]

可以将原list插空隔板，将隔板位置理解为索引位置，即一个索引一个值，原list做如下转变
  **0**   **1**   **2**   **3**   **4**   **5**   **6**   **7**   **8**   **9**   //原list
| **0** | **1** | **2** | **3** | **4** | **5** | **6** | **7** | **8** | **9**   //插隔板
0 **0** 1 **1** 2 **2** 3 **3** 4 **4** 5 **5** 6 **6** 7 **7** 8 **8** 9 **9**   //隔板转换为索引
			 1 **1** 2 **2** 3                             //取1与3索引之间的值

x[0:-1] =   [0, 1, 2, 3, 4, 5, 6, 7, 8]     //-1即最后一个位置（索引），等价与9 x[0:9]
x[-3:]      =   [7,8,9]                     //-3倒数第三个索引，即7，x[7:],从7取值到结束，不是x[7:9]
x[0:3:2]    =   [0,2]
x[1:3:2]    =   [1]
x[::2]      =   [0,2,4,6,8]

## 序列赋值
x[0]=8
x[1]=[2,3,4]
x[0:1]=[3]
x[0:1]=[3]
x[::2]=[99,99,99,99,99] #x将变为： [99, 1, 99, 3, 99, 5, 99, 7, 99, 9]

## 一些运算
sum(x) min(x) max(x) len(x)

## 其他方法
x.append(var)           #追加元素,var可以是数值，字符串，列表
x.insert(index,var)     #两个参数非空，必须指定index,否则报错
x.pop(var)              #var为空返回最后一个元素，并从list中删除之，var不为空则返回指定下标的值，不存在下标时报错：pop index out of range
x.remove(var)           #删除第一次出现的该元素
x.count(var)            #该元素在列表中出现的个数
x.index(var)            #该元素的位置,无则抛异常
x.extend(list6)         #追加list６，即合并list到x上,这里注意，使用extend函数可以一次在一个列表中插入任意多个值，而不必须每次只使用append()一次一值的插入
x.sort()        #排序
x.reverse()     #倒序
x.clear()       #清空

del x[1]        #删除指定下标的元素
del x[1:3]      #删除指定下标范围的元素

## 复制list:
x1 = x      #x1为x的别名，用C来说就是指针地址相同，对x1操作即对x操作。
x1 = x[:]   #x1为x的克隆，即另一个拷贝。

## 输出example
```python
L = [
    ['Apple', 'Google', 'Microsoft'],
    ['Java', 'Python', 'Ruby', 'PHP'],
    ['Adam', 'Bart', 'Lisa']
]
# 打印Apple:
print(L[0][0])
# 打印Python:
print(L[1][1])
# 打印Lisa:
print(L[2][2])
```

------------

# tuple元组
声明，用一个小括号
lastname=('li','zhang','liu');

tuple和list非常类似，但是tuple一旦初始化就不能修改，它也没有append()，insert()这样的方法。
其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。

不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！

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语句来删除整个元组。例如：del t3

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

--------------

# dict字典
类似json,redis,key-value库方式
与列表区别：字典是无序的，在字典中通过键来访问成员。 
字典是可变的，可以包含任何其他类型

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

```
>>> score={'zhang':80,'liu':90,'ma':85}
>>> score['zhang']
80
>>> score.get('zhang')
80
>>> score.get('li')
>>> score.get('li',100)
100
>>> score.keys()
dict_keys(['liu', 'zhang', 'ma'])
>>> score.values()
dict_values([90, 80, 85])
>>> score.pop('ma')
85
>>> score
{'liu': 90, 'zhang': 80}
>>> score.update({'zhou':99})
>>> score
{'liu': 90, 'zhang': 80, 'zhou': 99}
>>> score.update({'zhang':88})
>>> score
{'liu': 90, 'zhang': 88, 'zhou': 99}
>>> score.items()
dict_items([('liu', 90), ('zhang', 88), ('zhou', 99)])
>>> l = score.items()
>>> l
dict_items([('liu', 90), ('zhang', 88), ('zhou', 99)])
>>> l[0]
Traceback (most recent call last):
  File "<pyshell#127>", line 1, in <module>
    l[0]
TypeError: 'dict_items' object does not support indexing
>>> l = list(score.items())
>>> l
[('liu', 90), ('zhang', 88), ('zhou', 99)]
>>> l[0]
('liu', 90)
```

> 需要将items对象转换为list后，调用才不会报错～
>
> In Python 2.x, G.keys() returns a list, but Python 3.x returns a dict_keys object instead. The solution is to wrap G.keys() with call to list(), to convert it into the correct type

# set集合
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。

## 声明定义
```
#定义一个集合
>>> set1 = {1, 2, 3, 4, 5}
>>> set1
{1, 2, 3, 4, 5}
# 或者使用 set 函数
>>> list1=[6,7,7,8,8,9]
>>> set2=set(list1)
>>> set2
{8, 9, 6, 7}
```

## 增加与删除
删除不存在的值会报错～
```
>>> set2.add(10)
>>> set2
{8, 9, 10, 6, 7}
>>> set2.remove(2) 
Traceback (most recent call last):
  File "<pyshell#153>", line 1, in <module>
    set2.remove(2)
KeyError: 2
>>> set2.remove(7)
>>> set2
{8, 9, 10, 6}
```

## 交并集操作
set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：
```
>>> set1
{1, 2, 3, 4, 5}
>>> set2
{8, 9, 10, 6, 7}
>>> set1 & set2
set()
>>> set1 | set2
{1, 2, 3, 4, 5, 6, 7, 8, 9, 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.add(obj) #在集合s中添加对象obj
s.remove(obj) #从集合s中删除对象obj，如果obj不是集合s中的元素（obj not in s）,将引发keyError错误
s.pop() #删除集合s中得任意一个对象，并返回它
s.clear() #删除集合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.discard(obj) #如果obj是集合s中的元素，从集合s中删除对象obj

## 集合有并集，交集，求差操作
## 并集：intersection() 方法返回一个新集合，包含在两个集合中同时出现的所有元素。
## 交集：union() 方法返回一个新集合，包含在两个 集合中出现的元素。
## 差集：difference() 方法返回的新集合中，包含所有在 集合A出现但未在集合B中的元素。
## symmetric_difference() 方法返回一个新集合，包含所有只在其中一个集合中出现的元素。
# 删除元素
set2.discard(6) # 当元素不存在时,不会引发异常
set2.remove(6) # 与discard的区别在于，如果没有要删除的元素，remove会引发一个异常
set2.pop() # 因为set是无序的，所以pop会随机的从set中删除一个元素
```

参考文章：
1. https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000?_blank
2. https://blog.csdn.net/liuyanfeier/article/details/53731239?_blank

------本文结束感谢阅读------

上一篇：python（二）条件判断与循环（if else for while）

下一篇：python（四）列表元组字典集合复习and区别与相互转换