首页 > 代码库 > Python中list(列表)、tuple(元组)、dict(字典)基本操作快速入门

Python中list(列表)、tuple(元组)、dict(字典)基本操作快速入门


最近看了一下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(字典)基本操作快速入门