1、列表

列表：使用方括号将用逗号分隔不同的数据项括起来。 可以存储不同类型的数据。

list = [1,‘a’,[1,2 ],“python”]

创建列表

list = [obj0,obj1]

list1 = [1,2,3]     
list2 = ["C","python","java"]
list3 = []    #创建一个空列表

访问列表

list[index]

list = ['a', 'b', 'c', 'd']
print("list[1] :",list[1])		#获取索引为1的元素
print("list[1] :",list[-1])		#获取倒数第一个元素
print(list[1:3:1])				#使用切片获取元素 [1,3),步长为1


#结果：
list[1] : b
list[-1] : d
['b', 'c']

遍历列表

list = ["C","python","java","php"]
for i in list:
     print(i)
#结果：
C
python
java
php

遍历列表（需要获取索引值）enumerate()

list = ["C","python","java","php"]
for index,item in enumerate(list):
    print(index,item)
#结果：
0 C
1 python
2 java
3 php

添加、修改列表

list.append(obj) 在列表末尾添加新的对象
list.insert(index,obj) 添加元素到指定位置
list[index] = obj 修改元素
oidlist.extend(newlist) 添加列表

list = [1,2,3,4,5,6]
list1 = [7,8,9]
list.append("python")		#在列表末尾添加新元素
list.insert(1,"a") 			#添加“a”索引为1
list[0] = "b" 				#修改索引为0的元素
list.extend(list1)			#添加list1
list.pop()					#移除列表中的最后一个元素，并返回
list.pop(1)					#移除列表中索引为1的元素，并返回


#列表的变化依次  为：
[1, 2, 3, 4, 5, 6, 'python']
[1, 'a', 2, 3, 4, 5, 6, 'python']
['b', 'a', 2, 3, 4, 5, 6, 'python']
['b', 'a', 2, 3, 4, 5, 6, 'python', 7, 8, 9]
['b', 'a', 2, 3, 4, 5, 6, 'python', 7, 8]
['b', 2, 3, 4, 5, 6, 'python', 7, 8]

获取列表的最大、最小值、长度、和

max(list)
min(list)
len(list)
sum(list)

list = [12,14,52,84,34,13,21]
print("max(list):",max(list)) 		#获取最大值
print("min(list):",min(list))		#获取最小值
print("len(list):",len(list))		#获取列表长度
print("sum(list):",sum(list))		#获取元素之和


#结果：
max(list): 84
min(list): 12
len(list): 7
sum(list): 230

对列表进行排序

list.sort() 升序，原列表改变
list.sort(key =str.lower，reverse=False) 不区分字母大小写升序， reverse=True降序 原列表改变
sorted（list, key =str.lower，reverse=False) 不区分字母大小写升序， reverse=True降序 原列表不变

list1 = [11,8,45,72,31,43,6,1]
list2 = ["a","B","c","D","e","f","G"]
list1.sort()						#升序排列
list2.sort()						#升序排列
print(list1)
print(list2)					
#结果                   原序列改变
[1, 6, 8, 11, 31, 43, 45, 72]
['B', 'D', 'G', 'a', 'c', 'e', 'f']



=================================================================

list = ["a","B","c","D","e","f","G"]
list.sort(key = str.lower,reverse = True)			#不区分大小写降序排列
print(list)
#结果
['G', 'f', 'e', 'D', 'c', 'B', 'a']



=================================================================

list = ["a","B","c","D","e","f","G"]
a = sorted(list, key =str.lower,reverse=True) #不区分大小写降序排列
print(a)
print(list)
#结果
['G', 'f', 'e', 'D', 'c', 'B', 'a']
['a', 'B', 'c', 'D', 'e', 'f', 'G']

列表推导式

list = [expression for i in fun if conditionj]
随机生成10个0到20的数，组成列表

import random
list1 = [random.randint(0,20) for i in range(10)]
print(list1)
#结果
[9, 13, 10, 1, 2, 16, 11, 0, 3, 9]

删除列表

del list()
list.remove(obj)

list1 = ['a', 'b', 'c', 'd']
list2 = [1,2,3,4,5,6]
list3 = ['C', 'java','python']
del list2[2]			 #删除list2中索引为2的元素 	
list3.remove("python")	 #删除list3中"python"元素
del list1 				 #删除list1

#结果：
list2 = [1, 2, 4, 5, 6]
list3 = ['C', 'java']
list1被删除

其余操作

二维列表：

list = [[1,2,3],[11,12,13],[21,22,23]]

list = [12,41,31,54,12,78,31,71,12]
print(list.count(12))				#获取元素12出现的次数
print(list.index(71))				#获取71对应的索引

#结果：
3
7

list1 = [1,2,3]
list2 = [4,5,6]
print(list1+list2)		#列表相加
print(list1*3)			#重复列表
print(1 in list1)		#判断元素是否在列表中
#结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 1, 2, 3, 1, 2, 3]
True

2、元组

元组和列表相似，差异在于元组是只读的，不能修改，用“()”表示。
tuple = （‘a’, ‘b’, ‘c’, ‘d’）

元组和列表的区别

创建元组

tuple = ()

tup1 = (1,2,3,4,5,6)
tup2 = ("C","python","java")
tup3 = ()   #创建一个空元组
tup4 = (1,)  #只有一个元素，需要在后面加上','，否则会当成整型处理

访问元组

tuple(index)

tup1 = (1,2,3,4,5,6)
print(tup1[2])  			#获取索引为2的元素
print(tup1[-2])			#获取倒数第二个元素
print(tup1[0:5:2])		#使用切片获取元素 [0,5),步长为2
#结果：
3
5
(1, 3, 5)

添加、修改元组

元组中的元素值是不允许修改的，但可以连接组合

tup1 = (12,34,56)
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2		#
print (tup3)
print(tup1*2)
#结果：
(12,34,56, 'abc', 'xyz')
(12,34,56, 12,34,56)

获取元组的最大、最小值、长度、和

和列表相似

tup = (8,12,45,34,21,84,99,6)
print("max(tup):",max(tup)) 		#获取最大值
print("min(tup):",min(tup))		#获取最小值
print("len(tup):",len(tup))		#获取元组长度
print("sum(tup):",sum(tup))		#获取元素之和

#结果：
max(tup): 99
min(tup): 6
len(tup): 8
sum(tup): 309

删除元组

元组中的元素不能删除，可以使用del语句来删除整个元组。

tup = (1,2,3,4,5,6)
del  tup 	#删除整个元组

3、字典

最外面用{}，每一组用”:“连起来，各组用”,“隔开，可存储任意类型对象。值可以取任何数据类型，但键必须是不可变的,可以用数字，字符串或元组充当，不能为列表。
dictionary = {‘key1’:‘value1’ , ‘key2’:‘value2’ , ‘key3’:‘value3’ , ‘key4’:‘value4’}

创建字典

创建字典: {1:‘one’ , 2:‘two’ , 3:‘three’ ,4:‘four’}

 #直接生成
 dict = {1:'one' , 2:'two' , 3:'three' ,4:'four'}

==========================================

#由两个列表生成
list1 = [1,2,3,4]
list2 = ['one','two','three','four']
dictionary = dict(zip(list1,list2))	
==========================================
dict = {} 		#创建空字典	

dictionary=dict.fromkeys(key) 只有键 值暂定

key = [1,2,3,4]
dictionary=dict.fromkeys(key) 
print(dictionary)
#结果：
{1: None, 2: None, 3: None, 4: None}

访问字典

通过键获取字典元素： dict(key)

dict = {1:'one' , 2:'two' , 3:'three' ,4:'four'}
print("dict[1]:",dict[1])   #1表示键，并非索引
#结果:
dict[1]: one

dictionary.get(key,default)
key存在时,返回键对应的值,不存在时返回default,默认为None。

dict = {1:'one' , 2:'two' , 3:'three' ,4:'four'}
print("dict[1]:",dict[1])
print(dict.get(5))
print(dict.get(5,"字典中无对应元素"))
#结果:
dict[1]: one
None
字典中无对应元素

遍历字典：
dictionary.item()

dict = {1:'one' , 2:'two' , 3:'three' ,4:'four'}
for key,value in dict.items():
    print(key,"对应",value)
#for key in dict.keys():
#	print(key)       只输出key(value同理)

#结果:
1 对应 one
2 对应 two
3 对应 three
4 对应 four

添加、修改字典

dictionary[key] = value

dict = {1:'one' , 2:'two' , 3:'three' ,4:'four'}
dict[5] = "five"        #增加
dict[1] = "first"       #修改

字典依次为：
{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}
{1: 'first', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}

删除字典

del
clear

dict1 = {1:'one' , 2:'two' , 3:'three' ,4:'four'}
del dict1[1]      #删除key为1的元素
print(dict1)
dict1.clear()     # 清空字典
print(dict1)
del dict1         # 删除字典
print(dict1)

#结果：
{2: 'two', 3: 'three', 4: 'four'}
{}
#字典被删除，不存在，报错。

其余函数

len(dict) 计算字典元素个数，即键的总数
dict.copy() 返回一个字典的浅复制
key in dict 如果键在字典dict里返回true，否则返回false

dict1 = {1:'one' , 2:'two' , 3:'three' ,4:'four'}
print(len(dict1))				#计算字典元素个数，即键的总数
dict2 = dict1.copy()
print(dict2)#返回一个字典的浅复制
print(3 in dict1)			#如果键在字典dict里返回true，否则返回false

#结果：
4
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}
True

4、集合

用大括号 { } 或者 set() 函数创建集合，无序，不重复，不支持索引。
set = {‘a’, ‘b’, ‘c’, ‘d’}

创建集合

创建字典 set = {‘a’, ‘b’, ‘c’, ‘d’}

set = {'a', 'b', 'c', 'd'}		#直接生成
==========================================

list = ['a', 'b', 'c', 'd']
set1 = set(list)				#使用列表生成集合
==========================================

set()							#创建空集合

添加、删除集合

setname.add()  #添加元素

setname.remove()   # 删除指定元素
setname.pop()      # 随机删除元素
setname.clear()    # 清空集合

集合的交、并、差、对称差集

交集 & 并集 | 差集 - 对称差集 ^

set1 = {1,2,3,4,5,6}
set2 = {4,5,6,7,8,9}
print(set1&set2)
print(set1|set2)
print(set1-set2)
print(set1^set2)


#结果
{4, 5, 6}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
{1, 2, 3}
{1, 2, 3, 7, 8, 9}

其余函数

copy()	            拷贝一个集合
difference()	    返回多个集合的差集
intersection()	    返回集合的交集
intersection_update()	删除集合中的元素，该元素在指定的集合中不存在。
isdisjoint()	    判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	        判断指定集合是否为该方法参数集合的子集。
issuperset()	    判断该方法的参数集合是否为指定集合的子集
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	            返回两个集合的并集

最后

以上就是热情水壶为你收集整理的Python中的列表、元组、字典、集合详解1、列表2、元组3、字典4、集合的全部内容，希望文章能够帮你解决Python中的列表、元组、字典、集合详解1、列表2、元组3、字典4、集合所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。