当前位置: 代码迷 >> 综合 >> Python中的列表(list),元组(Tuple),字典(Dict)和集合(Set)
  详细解决方案

Python中的列表(list),元组(Tuple),字典(Dict)和集合(Set)

热度:34   发布时间:2023-12-15 18:52:50.0

原文链接:https://blog.csdn.net/liuyanfeier/article/details/53731239
一,列表(list)
定义一个列表使用一对中(方)括号”[ ] “。

python内置的一种数据类型是列表:list是一种有序的数据集合,可以随意的添加和删除其中的数据。比如列出班里所有的同学的名字,列出所有工厂员工的工号等都是可以用到列表的。

不知道有没有人和我一样,刚刚接触列表对于说的这个有序不是很懂,不知道是什么有序。等我自己查资料的时候才知道,这个有序不是说list中的元素自己自动排好了序,而说的是这下面的这种情况:

>>> list1 = ['1','2','3']
>>> list2 = ['2','3','1']
>>> list1 == list2
False
>>> list1 is list2
False
>>> list3 = ['1','2','3']
>>> list1 == list3
True
>>> list1 is list3
False
>>>
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

也就是说Python中是划分位置的,此为有序。

下面我们来看看Python中的列表的一些基本操作。
1.可以使用len()函数获得列表的长度(字典中的元素的个数);
2.可以使用索引来引用列表中的元素,注意:列表中的索引是从0开始的,并且在列表中还支持负索引;
3.list是一个可以变的有序列表,因此可以往你自己的列表中添加和删除元素:在末尾添加元素用的是append()方法,在指定的位置插入元素使用的是insert()方法;
4.在列表中删除元素:删除末尾的元素使用的是pop()方法,删除指定位置的元素使用pop(i),其中i是索引下标;
5.若想替换list中的某个元素,可以直接把该元素赋值给对应的元素下标即可;
6.在一个list中可以有不同的数据类型,可以有字符串类型,整型,或者bool等,并且list的元素中也可以有另外一个list,就相当于一个循环的嵌套一样。

list的方法:

L.append(var)          #追加元素
L.insert(index,var)
L.pop(var)               #返回最后一个元素,并从list中删除之
L.remove(var)            #删除第一次出现的该元素
L.count(var)             #该元素在列表中出现的个数
L.index(var)             #该元素的位置,无则抛异常
L.extend(list6)         #追加list6,即合并list到L上,这里注意,使用extend函数可以一次在一个列表中插入任意多个值,而不必须每次只使用append()一次一值的插入
L.sort()        #排序
L.reverse()     #倒序
del L[1]        #删除指定下标的元素
del L[1:3]      #删除指定下标范围的元素#复制list:
L1 = L      #L1为L的别名,用C来说就是指针地址相同,对L1操作即对L操作。
L1 = L[:]   #L1为L的克隆,即另一个拷贝。
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
list1 = ['you', 'me', 'her', 'he', 1000, 100000.123]print list1
print len(list1)
print list1[1],list1[-1]list1.append('it']
list1.insert(3,'30')
print list1list1.pop()
list1.pop(1)
print list1list1[2] = 'hello'
print list1list2 = ['wang','wu','luo',['lang','luo','zhang'],'kua']
print list2
print list2[3][1]list1.extend(list2)
print list1
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

输出:

['you', 'me', 'her', 'he', 1000, 100000.123]
6
me 100000.123
['you', 'me', 'her', '30', 'he', 1000, 100000.123, 'it']
['you', 'her', '30', 'he', 1000, 100000.123]
['you', 'her', 'hello', 'he', 1000, 100000.123]
['wang', 'wu', 'luo', ['lang', 'luo', 'zhang'], 'kua']
luo
['you', 'her', 'hello', 'he', 1000, 100000.123, 'wang', 'wu', 'luo', ['lang', 'luo', 'zhang'], 'kua']
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

二,元组(Tuple)
定义一个元组使用一对小(圆)括号”( ) “。

和列表类似,元组也是一种有序列表,虽然tuple和list非常之类似,但是list初始化之后使可以改变的,但是,元组一旦初始化之后就不可以改变。这点与Python中的字符串类似,所以我们说元组和字符串都是不可变的序列。

现在tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样的,你可以正常地使用tuple[0],tuple[-1],但不能赋值成另外的元素。
不可变的tuple有什么意义?因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。

tuple的陷阱
1.当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来;
2.定义只有一个元素的Tuple的时候,需要这样:
tuple1 = (123,)
后面要加上一个逗号,这是因为括号()既可以表示tuple,又可以表示数学公式中的小括号,这就产生了歧义。
tuple2 = (123) #如果你这样定义你定义的将是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)
>>>
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

元组中的元素值是不允许删除的,但我们可以使用del语句来删除整个元组。

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

三,字典(Dict)
定义 Dictionary 使用一对大(花)括号” { } ”。
字典(Dictionary) 是 Python 的内置数据类型之一,它定义了键和值之间一对一的关系,但它们是以无序的方式储存的。字典中的“值”通过键来引用。

与列表区别:字典是无序的,在字典中通过键来访问成员。
字典是可变的,可以包含任何其他类型

声明:
M={k1:v1,k2:v2}
访问 M[k1]将得到v1

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

get()语法:
dict.get(key, default=None)
参数
key – 字典中要查找的键。
default – 如果指定键的值不存在时,返回该默认值值。
返回值
返回指定键的值,如果值不在字典中返回默认值None。

#字典操作 
m = {
   'a':1,'b':2,'c':3}  
print(m)  
#读取某一个_通过key 
print(m['a'])  
#读取某一个,通过get方法 
print(m.get('b'))  
#复制字典 
m2 = m.copy()  
print(m2)  
#获取所有键的列表 
print( m.keys() )  
#获取所有值的列表 
print( m.values() )  
#获取所有键值对元组组成的列表 
print( m.items() )  
#更新成员,当对应键值不存在时,相当于加入 
m.update({
   'd':4})  
print(m)  
#删除某个成员 
m.pop('a')  
print(m)  
#遍历
from key in m.keys():if(key=='x'):del m[key]
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

四,集合(Set)
Python的集合(set)和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素.

#定义一个集合
set1 = {
   1, 2, 3, 4, 5}
# 或者使用 set 函数
list1 = [6, 7, 7, 8, 8, 9]
set2 = set(list1)
set2.add(10) # 添加新元素
print set2 # set([8, 9, 6, 7]) 去掉重复内容,而且是无序的
set3 = frozenset(list1)    #固定集合
set3.add(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.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.add(obj) #在集合s中添加对象obj
s.remove(obj) #从集合s中删除对象obj,如果obj不是集合s中的元素(obj not in s),将引发keyError错误
s.discard(obj) #如果obj是集合s中的元素,从集合s中删除对象obj
s.pop() #删除集合s中得任意一个对象,并返回它
s.clear() #删除集合s中的所有元素
## 集合有并集,交集,求差操作
## 并集:intersection() 方法返回一个新集合,包含在两个集合中同时出现的所有元素。
## 交集:union() 方法返回一个新集合,包含在两个 集合中出现的元素。
## 差集:difference() 方法返回的新集合中,包含所有在 集合A出现但未在集合B中的元素。
## symmetric_difference() 方法返回一个新集合,包含所有只在其中一个集合中出现的元素。
# 删除元素
set2.discard(6) # 当元素不存在时,不会引发异常
set2.remove(6) # 与discard的区别在于,如果没有要删除的元素,remove会引发一个异常
set2.pop() # 因为set是无序的,所以pop会随机的从set中删除一个元素
  
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  相关解决方案