标签：python 列表(list) 元组(tuple) 字典(dict)
最近看了一下Python的列表、字典以及元组等几种数据类型，感觉这几种数据类型比较常用，顺便总结了一下一些比较常用的用法。
列表是Python中比较常用的数据类型，并且列表是可以改变的，使用也非常简单，具体操作如下：
1）如创建一个列表：
list1 = [1,2,3] list2 = [‘a‘,‘b‘,‘c‘] list3 = [1,2,3,‘a‘,‘b‘,‘abc‘] list4 = [1,[2,3],[‘a‘,‘b‘,‘‘c]] #创建一个有序列表 list5 = range(10) #创建一个二维列表 list6 = [[ 0 for col in range(10)] for row in range(10)]
2）访问列表中的值
#!/usr/bin/env python # -*-coding:UTF-8 -*- list1 = [1,2,3,4,5,6] #如取出list1列表中第二个元素的值：(注意：列表的下标是从0开始的) print(‘list1列表的第二个元素的值为：%d‘ % list1[1]) #如果想取出其它元素以此类推 #输出列表中的所以元素的值 print(‘遍历输出list1所有元素的值：‘) for i in list1: print(i) #输出列表中奇数项的值（即取出列表中第1、3、5...等项的值） print(‘输出list1中奇数项元素的值：‘) for j in list1[::2]: #这里使用了列表的切片以及步长 print(j) list2 = [1,2,[3,4,[6,7,8]]] #取出列表list2中的值3的元素 print(‘取出列表list2%s中的值3的元素：‘ % list2) print(list2[2][0]) ‘‘‘ 原理：首先看数值3在一个子列表中，而这个子列表属于外层列表（父列表）的第三个元素，先取出含有数值3的子列表即：list2[2],由于list2[2]仍然是一个列表，而数值3处于这个列表的第一个元素的位置，所以 我们仍可以按照列表的操作取出list2[2]这个子列表的第一个元素list2[2][0]，即取出了值为3的元素。 ‘‘‘ #取出列表list2中的值8的元素 print(‘取出列表list2%s中的值8的元素：‘ % list2) print(list2[2][2][2]) #参照上边以此类推 ‘‘‘运行结果如下： list1列表的第二项的值为：2 遍历输出list1所有元素的值： 1 2 3 4 5 6 输出list1中奇数项元素的值： 1 3 5 取出列表list2[1, 2, [3, 4, [6, 7, 8]]]中的值3的元素： 3 取出列表list2[1, 2, [3, 4, [6, 7, 8]]]中的值8的元素： 8 ‘‘‘
3）增加或者修改列表的值
#!/usr/bin/env python #-*- coding:UTF-8 -*- list3 = [‘Python‘,‘Java‘,‘Php‘] print(‘原列表list3为：%s‘ % list3) #给list3添加一个元素 list3.append(‘C#‘) print(‘给list3添加一个元素C#：%s‘ % list3) #修改列表list3的第一个值为Python3 list3[0] = ‘Python3‘ print(‘修改列表list3的第一个元素的值为Python3：%s‘ % list3) ‘‘‘运行结果如下： 原列表list3为：[‘Python‘, ‘Java‘, ‘Php‘] 给list3添加一个元素C#：[‘Python‘, ‘Java‘, ‘Php‘, ‘C#‘] 修改列表list3的第一个元素的值为Python3：[‘Python3‘, ‘Java‘, ‘Php‘, ‘C#‘] ‘‘‘
4）删除列表中的元素
#!/usr/bin/env python #-*- coding:UTF-8 -*- list4 = [‘Python‘,‘Java‘,‘Php‘,‘Go‘] print(‘原列表为：%s‘ % list4) #删除值为Php的元素 del list4[2] print(‘删除值为Php的元素：%s‘ % list4) #删除值为Go的元素 list4.pop() print(‘删除值为Go的元素：%s‘ % list4) ‘‘‘运行结果如下: 原列表为：[‘Python‘, ‘Java‘, ‘Php‘, ‘Go‘] 删除值为Php的元素：[‘Python‘, ‘Java‘, ‘Go‘] 删除值为Go的元素：[‘Python‘, ‘Java‘] ‘‘‘
5）列表的一些其它基本操作
#!/usr/bin/env python
#-*- coding:UTF-8 -*-
list1 = [1,2,3,4,5]
list2 = [‘Python‘,‘Java‘,‘Php‘,‘Go‘]
print(‘列表list1为：%s‘ % list1)
print(‘列表list2为：%s‘ % list2)
#获得列表list1的长度
l = len(list1)
print(‘列表list1的长度为：%d‘ % l)
#合并list1和list2成为一个新的列表list3
list3 = list1 + list2
print(‘合并list1和list2成为一个新的列表：%s‘ % list3)
#创建一个指定长度且元素值相同的列表list4
list4 = [‘Python‘] * 4
print(‘创建一个指定长度且元素值相同的列表：%s‘ % list4)
#判断元素3是否存在于列表list1中
f = 3 in list1
print(‘判断元素3是否存在于列表list1中：%s‘ % f)
#截取列表list2中第二个元素以后的值
list5 = list2[1:]
print(‘截取列表list2中第二个元素以后的列表元素：%s‘ % list5)
#获取列表list1中的元素的最大值
max_value = max(list1)
print(‘列表list1中元素的最大值为：%d‘ % max_value)
#获取列表list1中元素的最小值
min_value = min(list1)
print(‘列表list1中元素的最小值为：%d‘ % min_value)
#将元组转化成列表
a = (1,2,3)
list6 = list(a)
print(‘元组(1,2,3)转化成的列表为：%s‘ % list6)
#将字符串转化成列表
s = ‘abc‘
list7 = list(s)
print("字符串‘abc‘转化成的列表为：%s" % list7)
#列表转化成字符串：
list8 = "".join(list7)
print("列表[‘a‘,‘b‘,‘c‘]转化成的字符串为：%s" % list8)
#应用场景如:做一个加法运算的拼接
# expr = "+".join([1,2,3])
#结果为：1+2+3
‘‘‘运行结果如下：
列表list1为：[1, 2, 3, 4, 5]
列表list2为：[‘Python‘, ‘Java‘, ‘Php‘, ‘Go‘]
列表list1的长度为：5
合并list1和list2成为一个新的列表：[1, 2, 3, 4, 5, ‘Python‘, ‘Java‘, ‘Php‘, ‘Go‘]
创建一个指定长度且元素值相同的列表：[‘Python‘, ‘Python‘, ‘Python‘, ‘Python‘]
判断元素3是否存在于列表list1中：True
截取列表list2中第二个元素以后的列表元素：[‘Java‘, ‘Php‘, ‘Go‘]
列表list1中元素的最大值为：5
列表list1中元素的最小值为：1
元组(1,2,3)转化成的列表为：[1, 2, 3]
字符串‘abc‘转化成的列表为：[‘a‘, ‘b‘, ‘c‘]
列表[‘a‘,‘b‘,‘c‘]转化成的字符串为：abc
‘‘‘6）Python列表包含的方法示例
#!/usr/bin/env python #-*- coding:UTF-8 -*- #注意以下的列表操作都是对原列表进行操作 list = [3,2,4,1,5] print(‘原列表list为：%s‘ % list) #在列表尾部添加新元素 list.append(6) print(‘在列表尾部添加新元素6：%s‘ % list) #在list列表的第2个位置插入一个新元素3 list.insert(1,3) #注意列表的下标是从0开始 print(‘在list列表的第2个位置插入一个新元素3：%s‘ % list) #在列表尾部追加另一个列表的值 list1 = [1,2,3] list.extend(list1) print(‘在列表尾部追加另一个列表%s的值：%s‘ % (list1,list)) #统计列表list中值为3的元素出现的次数 count = list.count(3) print(‘统计列表list中值为3的元素出现的次数：%d‘ % count) #找出列表list中第一个值3的元素的索引 index = list.index(3) print(‘找出列表list中第一个值3的元素的索引：%d‘ % index) #移除列表中第2个元素 #####注意：默认情况下list.pop()是移除列表的最后一个元素 list.pop(1) #注意list下标是从0开始 print(‘移除列表中第4个元素：%s‘ % list) #移除列表中第一个值为3的元素 list.remove(3) print(‘移除列表中第一个值为3的元素：%s‘ % list) #对list列表进行排序 list.sort() #默认是按照ASSCII来排序的 print(‘对list列表进行排序：%s‘ % list) #反转列表中的元素 list.reverse() print(‘反转列表中的元素：%s‘ % list) #反转列表中的元素 list.reverse() print(‘反转后的列表为：%s‘ % list) ‘‘‘运行结果如下所示： 原列表list为：[3, 2, 4, 1, 5] 在列表尾部添加新元素6：[3, 2, 4, 1, 5, 6] 在list列表的第2个位置插入一个新元素3：[3, 3, 2, 4, 1, 5, 6] 在列表尾部追加另一个列表[1, 2, 3]的值：[3, 3, 2, 4, 1, 5, 6, 1, 2, 3] 统计列表list中值为3的元素出现的次数：3 找出列表list中第一个值3的元素的索引：0 移除列表中第4个元素：[3, 2, 4, 1, 5, 6, 1, 2, 3] 移除列表中第一个值为3的元素：[2, 4, 1, 5, 6, 1, 2, 3] 对list列表进行排序：[1, 1, 2, 2, 3, 4, 5, 6] 反转列表中的元素：[6, 5, 4, 3, 2, 2, 1, 1] ‘‘‘
7）list列表的深浅拷贝比较及原理讲解
#!/usr/bin/env python #-*- coding:UTF-8 -*- #list列表浅拷贝示例 import copy list1 = [1,2,3,[4,5,6]] list2 = list1.copy() print(‘list1的值为：%s‘ % list1) print(‘list2的值为：%s‘ % list2) ‘‘‘运行结果为 list1的值为：[1, 2, 3, [4, 5, 6]] list2的值为：[1, 2, 3, [4, 5, 6]] ‘‘‘ #修改list2中的值 list2[0] = 3 print(‘list1的值为：%s‘ % list1) print(‘list2的值为：%s‘ % list2) ‘‘‘运行结果为： list1的值为：[1, 2, 3, [4, 5, 6]] list2的值为：[3, 2, 3, [4, 5, 6]] 我们将list1拷贝了一份给list2，当修改list2的第一个元素值为3的时候，list1的值并没有发生改变， 这个很好理解，那么请继续往下边看 ‘‘‘ #继续修改list2的值，这次修改list2子列表的值 list2[3][0] = 5 print(‘list1的值为：%s‘ % list1) print(‘list2的值为：%s‘ % list2) ‘‘‘ list1的值为：[1, 2, 3, [5, 5, 6]] list2的值为：[3, 2, 3, [5, 5, 6]] 通过这次修改，我们会惊讶的发现，我们这次将list2的子列表的第一个元素修改为5，为什么list1的子列表中的第一个元素的值也跟着发生变化了呢？ 原因：浅拷贝只复制（拷贝）列表的第一层，还拿上边的为例来说，第一次当修改list2的第一个元素时，由于列表list1的第一个元素是一个真实的值，所以list2在拷贝的时候直接把这个值拷贝了过来，所以list2在修改这个值时，不会影响list1的值；而在list2第二次修改的时候，修改的是子列表中的值，而在list1中第四个位置存储的并不是子列表的值，而是子列表的一个引用地址，由于浅拷贝只拷贝（复制）了一层，所以list2在拷贝的时候，是把list1中子列表的引用地址拷贝了过来，这时list1和list2中的第四个元素存放一个相同的引用地址，都指向了同一个子列表，所以当修改list1或者list2中任意一个中的子列表的值时，另一个列表的子列表的值也会跟着变化。 注意： 浅拷贝的几种方式 p1 = copy.copy(list1) p2 = list1[:] p3 = list(list1) 以上这几种方式都属于浅拷贝，使用的时候需要注意一点，不然会有坑。。。 ‘‘‘ ‘‘‘ 深拷贝的实现方式如下： list4 = copy.deepcopy(list1) 深拷贝其实就是完全把列表完全拷贝了一遍，修改任意一个，都不会影响另一个列表 ‘‘‘
2.元组（tuple）与列表很类似，最大的不同点在于元组的元素不能修改
1）创建元组
#创建一个空的元组 tup1 = () #创建只包含一个元素的元组 tup2 = (‘a‘,) #注意需要在元素后边添加逗号 #创建一个包含多个元素的元组 tup3 = (1,2,3,‘Java‘,‘Python‘,‘Php‘)
2）元组的基本操作
#!/usr/bin/env python #-*- coding:UTF-8 -*- tup1 = (1,2,3) tup2 = (‘Python‘,‘Java‘,‘Php‘,‘C#‘) #访问元组tup2中的第一个元素 s = tup2[0] print(‘访问元组tup2中的第一个元素：%s‘ % s) #遍历输出元组tup2中的所有元素： print(‘遍历输出元组tup2中的所有元素：‘) for i in tup2: print(i) #合并tup1和tup2为一个新的元组（即连接两个元组） tup3 = tup1 + tup2 #注意：这里并没有对元组做任何修改，而是将两个元组合并成了一个新的元组，老的元组并没有被修改。 print(‘合并tup1和tup2的新元组为：‘ , tup3) #删除元组 由于元组不能修改的特性，所以元组内的元素不允许删除，但是我们可以使用del来删除整个元组 del tup3 #如果将整个元组删除就不能在访问该元组，否则会出现not defined的异常错误 #计算元组tup2的长度： l = len(tup2) print(‘计算元组tup2的长度为：%d‘ % l) #判断元素3在元组tup1是否存在： b = 3 in tup1 print(‘判断元素3在元组tup1是否存在：%s‘ % b) #取出元组tup1中的最大值： max = max(tup1) print(‘元组tup1中的最大值：%d‘ % max) #取出元组tup1中的最小值： min = min(tup1) print(‘元组tup1中的最小值：%d‘ % min) #将列表转换为元组 list1 = [‘a‘,‘b‘,‘c‘] tup4 = tuple(list1) print(‘列表list1%s转换为元组：%s‘ % (list1, tup4)) #以上为列表的一些基本操作，主要元组是不可以修改，例如：tup1[1] = 10这样的操作是不合法的。 ‘‘‘运行结果如下： 访问元组tup2中的第一个元素：Python 遍历输出元组tup2中的所有元素： Python Java Php C# 合并tup1和tup2的新元组为： (1, 2, 3, ‘Python‘, ‘Java‘, ‘Php‘, ‘C#‘) 计算元组tup2的长度为：4 判断元素3在元组tup1是否存在：True 元组tup1中的最大值：3 元组tup1中的最小值：1 列表list1[‘a‘, ‘b‘, ‘c‘]转换为元组：(‘a‘, ‘b‘, ‘c‘) ‘‘‘
3.Python字典（dict）使用了key-value存储和其它语言中的map类似，格式要求为d = {key1:value1, key2: value2}，且可以存储任意类型的对象，但是字典的key是不可变类型，而value可以改变，并且只允许
同一个key出现一次（如果同一个key被赋值两次，则后一次会覆盖前一次的value）。
1）字典的一般定义形式如下：（注意字典dict的格式）
d1 = {‘a‘:1, ‘b‘:2, ‘c‘:3}
d2 = {‘北京‘:[‘昌平‘,‘朝阳‘,‘大兴‘,‘东城‘],‘上海‘:[‘虹口‘,‘嘉定‘,‘浦东‘,‘松江‘]}2）访问字典中的值
#!/usr/bin/env python
#-*- coding:UTF-8 -*-
d1 = {‘name‘:‘zhangsan‘,‘age‘:21,‘addr‘:‘beijing‘}
#输出字典d1中age的值
a = d1[‘age‘] #或者 a2 = d1.get(‘age‘)
print(‘输出字典d1中age的值：%d‘ % a)
#便利输出字典中的key和value
print(‘将字典转化成列表的形式遍历输出：‘)
print(‘d1.items()的结果为：‘, d1.items()) #items()将字典里边的键/值转化成了元组，将字典整个转换成包含元组的列表
for key,value in d1.items():
print(key,value)
print(‘直接遍历输出字典中的值：‘)
for i in d1:
print(i,d1[i])
‘‘‘运行结果如下：
输出字典d1中age的值：21
将字典转化成列表的形式遍历输出：
d1.items()的结果为： dict_items([(‘name‘, ‘zhangsan‘), (‘age‘, 21), (‘addr‘, ‘beijing‘)])
name zhangsan
age 21
addr beijing
直接遍历输出字典中的值：
name zhangsan
age 21
addr beijing
‘‘‘3）字典的一些其它基本操作，如修改、添加、删除
#!/usr/bin/env python
#-*- coding:UTF-8 -*-
d1 = {‘name‘:‘zhangsan‘,‘age‘:21,‘addr‘:‘beijing‘}
#为字典添加一个新的键值对‘gender‘:‘male‘：
d1[‘gender‘] = ‘male‘
print("为字典添加一个新的键值对‘gender‘:‘male‘后：",d1)
#修改d1中age的值为22：
d1[‘age‘] = 22
print(‘修改d1中age的值为22：‘,d1)
#删除d1中的addr
del d1[‘addr‘]
print(‘删除d1中的addr：‘,d1)
‘‘‘
d1.clear() #能够清空字典
del d1 #是删除字典
‘‘‘
#将两个列表合成一个字典
list1 = [‘a‘,‘b‘,‘c‘,‘d‘]
list2 = [1,2,3,4]
d2 = dict(zip(list1,list2))
print(‘将两个列表合成一个字典：‘,d2)
‘‘‘运行结果如下：
为字典添加一个新的键值对‘gender‘:‘male‘： {‘name‘: ‘zhangsan‘, ‘age‘: 21, ‘addr‘: ‘beijing‘, ‘gender‘: ‘male‘}
修改d1中age的值为22： {‘name‘: ‘zhangsan‘, ‘age‘: 22, ‘addr‘: ‘beijing‘, ‘gender‘: ‘male‘}
删除d1中的addr： {‘name‘: ‘zhangsan‘, ‘age‘: 22, ‘gender‘: ‘male‘}
将两个列表合成一个字典： {‘a‘: 1, ‘b‘: 2, ‘c‘: 3, ‘d‘: 4}
‘‘‘4）字典的内置方法的简单示例：
#!/usr/bin/env python
#-*- coding:UTF-8 -*-
d1 = {‘name‘:‘zhangsan‘,‘age‘:21,‘addr‘:‘beijing‘}
#获取字典d1的所有键(key)：
keys = d1.keys() #以列表形式返回所有键的值
print(‘获取字典d1的所有键(key)：‘, keys)
#获取字典d1的所有值(value)：
values = d1.values() #以列表形式返回所有value的值
print(‘获取字典d1的所有值(values)：‘, values)
#对字典进行一次浅拷贝
d2 = d1.copy() #返回字典的一个浅拷贝
print(‘原字典：‘,d1)
print(‘拷贝的字典：‘,d2)
#取出字典d1中键为addr的值
addr = d1.get(‘addr‘) #返回指定键的值，如果之不存在，则可以返会指定的默认值
print(‘取出字典d1中键为addr的值：%s‘ % addr)
#取出字典d1中键为gender的值，如果不存在就添加
g = d1.setdefault(‘gender‘,‘male‘) #如果字典中不存在该键，将会把该键以及指定的默认值添加进字典
print(‘取出字典d1中键为gender的值，如果不存在就添加：‘,d1)
#把另一个字典中的键值对跟新到字典d1中：
d3 = {‘hobby‘:‘meizi‘}
d1.update(d3) #把另个字典的键/值更新到d1中
print("把另一个字典d3{‘hobby‘:‘meizi‘}中的键值对跟新到字典d1中：", d1)
#删除字典中键age所对应的值，并将value返回
v = d1.pop(‘age‘) #删除字典中指定的键以及对应的值，并且返回键的值
print(‘删除字典中键age所对应的值，并将value返回：‘, v)
print(‘此时字典d1包含的项有：‘, d1)
#随机删除字典d1中的一对键值，并返回改键值对：
kv = d1.popitem() #随机删除字典中的一对键值并将结果返回
print(‘随机删除字典d1中的一对键值，并返回改键值对：‘, kv)
print(‘此时字典d1包含的项有：‘, d1)
#删除字典d1内的所有元素
d1.clear()
print(‘删除字典d1内的所有元素：‘, d1)
#创建一个新字典
d4={}.fromkeys((‘a‘,‘b‘),1) #创建一个新字典，以seq中的元素为键，以val为字典的键对应的初始值
print(‘创建一个新字典d4：‘, d4)
‘‘‘运行结果如下：
获取字典d1的所有键(key)： dict_keys([‘name‘, ‘age‘, ‘addr‘])
获取字典d1的所有值(values)： dict_values([‘zhangsan‘, 21, ‘beijing‘])
原字典： {‘name‘: ‘zhangsan‘, ‘age‘: 21, ‘addr‘: ‘beijing‘}
拷贝的字典： {‘name‘: ‘zhangsan‘, ‘age‘: 21, ‘addr‘: ‘beijing‘}
取出字典d1中键为addr的值：beijing
取出字典d1中键为gender的值，如果不存在就添加： {‘name‘: ‘zhangsan‘, ‘age‘: 21, ‘addr‘: ‘beijing‘, ‘gender‘: ‘male‘}
把另一个字典d3{‘hobby‘:‘meizi‘}中的键值对跟新到字典d1中： {‘name‘: ‘zhangsan‘, ‘age‘: 21, ‘addr‘: ‘beijing‘, ‘gender‘: ‘male‘, ‘hobby‘: ‘meizi‘}
删除字典中键age所对应的值，并将value返回： 21
此时字典d1包含的项有： {‘name‘: ‘zhangsan‘, ‘addr‘: ‘beijing‘, ‘gender‘: ‘male‘, ‘hobby‘: ‘meizi‘}
随机删除字典d1中的一对键值，并返回改键值对： (‘hobby‘, ‘meizi‘)
此时字典d1包含的项有： {‘name‘: ‘zhangsan‘, ‘addr‘: ‘beijing‘, ‘gender‘: ‘male‘}
删除字典d1内的所有元素： {}
创建一个新字典d4： {‘a‘: 1, ‘b‘: 1}
‘‘‘Python中list（列表）、tuple（元组）、dict（字典）基本操作快速入门
标签：python 列表(list) 元组(tuple) 字典(dict)
原文地址：http://10616534.blog.51cto.com/10606534/1942898
