最近看了一下Python的列表、字典以及元组等几种数据类型，感觉这几种数据类型比较常用，顺便总结了一下一些比较常用的用法。

1. 列表是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（字典）基本操作快速入门