当前位置:   article > 正文

元组、列表、字典、集合详细介绍说明_列表,元组,字典和集合的创建方法分别是什么?

列表,元组,字典和集合的创建方法分别是什么?

元组、列表、字典、集合

  • 元组和列表是Python语言中非常重要的一部分内容,它们是Python中除了字符串以外的另两种序列结构,几乎在任何地方都少不了它们的使用。而字典是非常具有Python语言特色的一种类型,它与列表类似,但是其中元素的顺序变的无关紧要。

1 列表

1.1 列表的创建

  • 列表可以由[]或者list()创建,它可以由零个或者多个元素组成,元素之间用逗号隔开,整个列表要被方括号所包裹:
	#创建空列表
>>>	empty_list	=	[]	#	Method one
>>>	empty_list	=	list()	#	Method two
	#创建非空列表
>>>	friends	=	['You','They','Me']
  • 1
  • 2
  • 3
  • 4
  • 5
  • 同时,除了我们自己创建列表之外,我们还可以用list()将其它形式的数据类型转换成列表类型:
	#	将字符串转换成列表:
>>>	list('goldsunC')
['g', 'o', 'l', 'd', 's', 'u', 'n', 'C']
	#	将元组转换成列表:
>>>	tuple	=	('You','They','Me')
>>>	list(tuple)
['You','They','Me']
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

1.2 列表的处理

1.2.1 列表分割
  • Python学习笔记(二)中我写了关于字符串的一些相关处理,其中有一个split()函数可以将字符串进行切割,相似的,这个函数也可以对列表进行切割:
>>>	Mybirthday	=	'11/03/2000'
>>>	Mybirthday.split('/')
['11','03'.'2000']	
#Tip:一定要注意空格也是字符
  • 1
  • 2
  • 3
  • 4
1.2.2 提取元素
  • 和字符串类似的,通过偏移位从列表中提取对应位置的元素:
>>> Myname	=	['Chang','kang','ning']
>>>	Myname[0]
'Chang'
>>>	Myname[1]
'kang'
>>>	Myname[-1]
'ning'
>>>	Myname[-2]
'kang'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

引用的偏移位对于待访问列表必须有效——该位置的元素在访问前已经正确赋值,当指定的偏移位小于起始位置或者大于末尾位置时,会产生异常。

  • 同时,也可以指定范围并使用切片提取元素:
>>> Myname	=	['Chang','kang','ning']
>>>	Myname[0:2]
['Chang','kang']
#	其提取方式与字符串相比是类似的,详细可参考上一章字符串的处理。
  • 1
  • 2
  • 3
  • 4
1.2.3 修改元素
  • 我们不但可以通过偏移位访问某元素,还可以通过赋值对它进行修改:
>>>	emotion	=['I','hate','you']
>>> emotion[1]='love'	#同样,偏移位的引用也必须时合法的
>>>	emotion
['I','love','you']
  • 1
  • 2
  • 3
  • 4
  • 使用此种方式无法修改列表内字符串中的指定字符,因为字符串本身是不可变的。而列表是可变的,因此你可以修改列表中的元素个数,以及元素的值。

1.3 列表的概念延伸

  • 列表可以包含各种类型的元素,也包括其它的列表,同时也可以对一个有内层列表,并可以在列表内有对象时可以无限层引用,如下例:
	#创建列表
>>>	Myname	=	['Chang','kang','ning']
>>>	emotion	=	['I','love','you']
>>>	friends	=	['You','They','Me']
>>>	whole	=	[Myname,emotion,friends,'friendship']
>>>	whole
[['Chang', 'kang', 'ning'], ['I', 'love', 'you'], ['You', 'They', 'Me'], 'friendship']
>>>	whole[0]
['chang','kang','ning']	#这说明第一个元素还是一个列表,其实它就是Myname
>>>	whole[0][0]
'Chang'
>>>	whole[1][1]
'love'
>>>	whole[1][1][1]
'o'
#这说明第一个[]指向whole的外层列表,而第二个[]指向whole的二层列表,第三个[]指向字符串。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

1.4 相关的列表处理函数

函数名称作用
append(element)element添加至列表尾部(其可以是任何元素)
extend(list) or +=list合并至原列表(注意与append区分)
insert(offset,element)offset处插入element(偏移位可以溢出)
remove(element)删除原列表中的所有element
pop(offset)(none==-1)获取并删除offset处的元素
index(element)查询element在列表中的偏移位
count(element)记录element在列表中出现的总次数
sort()对列表进行排序同时改变原列表内容(数字升序或者字母升序),降序则在()中写入reverse=Ture
sorted()返回排好序的列表副本,原列表内容不变
len(list)获取list的长度
  • 上边是我整理的一些对列表进行处理的函数,其实还有几个常用函数,因为其引用方式和上边那些稍有不同,因为我单独拿出并举例。

1.5 使用del删除指定位置的元素

	#创建列表
>>>	friends	=['You','They','Me']
>>>	del	friends[1]
>>>	friends
['You','Me']
  • 1
  • 2
  • 3
  • 4
  • 5
  • 当列表中的一个元素被删除后,位于它后面的元素会自动往前移动填补空出的位置,且列表长度减1。

1.6 使用join()将列表转换为字符串

	#创建一个列表
>>>	emotion	=['I','love','you']
>>>	result	=' '.join(emotion)
>>>	result
'I love you'
  • 1
  • 2
  • 3
  • 4
  • 5

1.7 使用in判断值是否存在于列表

	#创建一个列表
>>>	emotion	=['I','love','you']
>>>	'love'	in	emotion
True
>>>	'hate'	in	emotion
False
	#一个列表中可能存在多个相同的值,但只要至少出现一次,in就会返回	True
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

1.8 使用=赋值,使用copy()复制

  • 在这里我觉得有必要解释一下,在Python语言中,所有数据都是以对象的形式存在的,Python中的变量仅仅是一个名字,赋值操作并不会实际复制值,它只是为数据对象取了一个名字而已,名字是对对象的引用而不是对象本身。
  • 下面举个例子更好理解:
>>>	a	=[1,2,3,4,5]
>>>	b	=a
>>>	b
[1,2,3,4,5]
>>>	b[0]=0
>>>	b
[0,2,3,4,5]
>>>	a
[0,2,3,4,5]
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 如上例所示,a对b的赋值仅仅是值从新在a所指对象的身上贴上了b的标签,赋值后a和b实际指向的是一个对象,因此无论是通过a还是通过b来修改其所指对象的内容,其结果都会作用于双方。

如果想将一个列表的值复制到另一个新的列表中,可以采用以下三种方法:

  • 列表copy()函数
  • list()转换函数
  • 列表分片[:]
>>>	a	=[1,2,3,4,5]
>>>	b	=a.copy()
>>>	c	=list(a)
>>>	d	=a[:]
>>>	a,b,c,d
([1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5])
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

使用这三种方法产生的b、c、d都是a的复制,它们是自身带有值得新对象,与原始的a所指向的对象没有任何关联,此时改变任何一个对象的值都不影响其它对象。


2 元组

  • 其实元组和列表是非常相像的一种数据类型,其最大的不同便是:元组是不可变的。这意味着元组一旦被定义,将无法再进行增加、删除或者修改元素等操作。相对来说,元组就像一个常量列表。因为元组与列表非常相似,接下来只介绍一下元组的创建以及和列表对比的一些特点。

2.1 元组和列表各组特点

  • 在许多地方都可以用元组代替列表,但元组的方法函数比列表要少很多:比如没有append()insert()等函数,因为创建了元组之后便无法修改了,因此没有这些函数。那既然列表更加灵活,为什么不在所有地方都应用列表呢?有以下几点原因:

1.元组占用的空间较小
2.你不会意外修改元组的值以便防止程序发生雪崩式的漏洞
3.可以将元组作为字典的键
4.命名元组可以作为对象的替代
5.函数的参数是以元组的形式传递的

2.2 元组的创建

创建一个空元组用():

>>>	empty_tuple	=()
>>>	empty_tuple
()
  • 1
  • 2
  • 3

创建一个或者多个元素的元组时,每一个元素后面都要跟着一个逗号,即使只包含一个元素也不能省略,当创建的元组包含的元素大于1时,最后一个元素后面的逗号可以省略:

>>>	Myname	='ChangKangning',
>>>	Myname
('ChangKangning',)
>>>	Myname	='Chang','kang','ning'
>>>	Myname
('Chang','kang','ning')
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

在Python的解释器中输出元组时总会自动添加一对圆括号,而我们并不需要这样做-因为定义元组真正靠的是每个元素的后缀-“逗号”,不过你愿意加一对圆括号也可以,这样也会使得程序更加的清晰。

  • 可以一口气将元组赋值给多个变量:
>>>	Myname	='Chang','kang','ning'
>>>	a,b,c	=Myname
>>>	a
'Chang'
>>>	b
'kang'
>>>	c
'ning'
	#这个过程也被称作“元组解包”
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 同时,利用tuple()函数也可以将其他类型的数据转换成元组:
>>>	Myname	=['Chang','kang','ning']
>>>	tuple(Myname)
('Chang','kang','ning')
  • 1
  • 2
  • 3

3 字典

  • 字典与列表类似,但是其中的元素顺序变的无关紧要,因为字典并不是靠偏移位来访问的,每个元素不必被编相应的顺序序号。取而代之,每个元素拥有与之对应的互不相同的键(key),需要通过键来访问元素,键通常是字符串,但它还可以是Python中其他任意的不可变类型:布尔型、浮点型、元组、字符串,以及其他一些相关类型。而字典本身是可变的,因此你可以增加、删除或修改其中的键值对

3.1 字典的创建

3.1.1 使用{}创建字典
  • 使用大括号{}将一系列以逗号隔开的键值对(key:value)包裹起来即可进行字典的创建:
>>>	empty_dict	={}
>>>	empty_dict
{}
>>>	a_dict	={'Myname':'ChangKangning',
			  'Yourname':'XXX'}
>>>	a_dict
{'Myname': 'ChangKangning', 'Yourname': 'XXX'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • Python允许在列表、元组、或者字典的最后一个元素后面添加逗号,这不会产生任何问题。此外,在括号之间输入键值对来创建字典时并不强制要求缩进。
3.1.2 使用dict()转换为字典
  • 可以对任何包含双值子序列的序列使用dict()将其转化为字典:
	#包含双值元组的列表
>>>	example	=[('C','Chang'),('K','Kang'),('N','Ning')]
>>>	dict(example)
{'C': 'Chang', 'K': 'Kang', 'N': 'Ning'}
	#另外其它包含双值列表的元组、双字符的字符串、双字符串组成的元组等都可以
#	转化为字典,在此不一一举例。
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

3.2 字典的处理

3.2.1 使用方括号[]添加或者修改元素
  • 我们已经知道字典是由一对对的键值对组成,而向字典中添加元素非常简单,只需要指定该元素的键并赋予相应的值即可。如果该键已经有值,其将被新值取代,如果没有此键,此键值对将被加入字典。
>>>	name_dict	={'C':'Chang','K':'Kang'}
>>> name_dict
{'C':'Chang','K':'Kang'}
>>>	name_dict['N']='Ning'
>>>	name_dict
{'C': 'Chang', 'K': 'Kang', 'N': 'Ning'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 因为我们引用的是字典中键值对的键,因此我们需要知道,每个字典中包含的必须保证互不相同。
3.2.2 一些常用的字典处理函数
函数名称作用
update(other_dict)other_dict中的键值对复制到原字典
del dict[‘key’]删除dictkey的元素(类似列表中的del)
clear()将字典中的所有元素删除
’key‘ in dict判断key是否在字典中
keys()获取字典中的所有
values()获取字典中的所有
items()获取字典中的所有键值对
3.2.3 特别的处理方法
  • 与列表类似,同样的使用方括号[]来获取元素。
  • 在对字典的操作中,只需要指定字典名字即可得到对应的
>>>	name_dict	={'C':'Chang','K':'Kang','N':'Ning'}
>>>	name_dict['C']
'Chang'
  • 1
  • 2
  • 3
  • 注意,如果在操作的字典中不包含指定的键,则系统会报错而并不是返回空,而有两种方法可以避免这种情况发生:
    1. 3.2.2表中的in判断此键是否存在。
    1. 使用字典函数get(),你在使用时需要指定字典名、键、以及一个可选值。如果键存在,会返回其对应值。如果不存在,则返回这个可选值。

如下:

>>>	name_dict	={'C':'Chang','K':'Kang'}
>>>	name_dict.get('K','none')
'Kang'
>>>	name_dict.get('N','none')
'none'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 与列表一样,对字典内容信息的修改会反映到所有与之相关联的变量名上,若想避免此种情况,则还是需要用copy()函数将字典复制到一个新字典中。

4 集合

  • 对于元组和列表我们知道,元组就像是不会改变的列表,其性质非常相似,而对于字典与集合来讲,**集合就像设其了值,
  • 仅剩下键的字典一样**。集合里边的元素不允许重复,同时也没有顺序。如果你仅仅向知道某一个元素是否存在而不关心其他的东西,使用集合是一个非常好的选择。

4.1 集合的创建

4.1.1 使用set()函数创建集合
  • 我们可以使用set()函数创建一个集合,或者用大括号将一系列以逗号隔开的值包裹起来创建集合。如下所示:
>>>	empty_set	=set()
>>>	empty_set
set()
>>>	a_set	={1,2,3,4,5}
>>>	a_set
{1,2,3,4,5}	#虽然此时返回的值看似有序,但一定注意集合是无序的!!!
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 注意,空集合的创建并不是之间使用一个大括号就行了,大括号是用来创建字典的,为了避免与空字典的重复,解释器输出的空集合是set(),这样规定没有什么特殊原因,仅仅是因为字典的出现比较早吧。
4.1.2 使用set()将其他类型转换为集合

这里没什么好解释的,直接上例子:

>>>	set('ning')
{'i','n','g'}
	#如上所示,两个n变成了一个
	#将列表转换为集合
>>>	set(['Chang','kang','ning'])
{'ning', 'Chang', 'kang'}
	#将元组转换为集合
>>> set(('Chang','kang','ning'))
{'ning', 'Chang', 'kang'}
	#当字典作为参数传入set()函数时,只有键会被使用:
>>>	set({'C':'Chang','K':'Kang','N':'Ning'})
{'C','K','N'}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

4.2 集合的处理

  • 前边已经说过,集合里面的元素是无序的、唯一的,因此我们最常用的功能是判断元素是否存在于目标集合。
4.2.1 使用in判断测试值是否存在
	#我们先建立一个字典,字典里边的值为集合
>>>	a_dict	={
				'C':{'C','h','a','n','g'},
				'K':{'K','a','n','g'},
				'N':{'N','i','n','g'}
				}
>>>	for i,j in a_dict.items():
		if 'a' in j:
			print(i)
'C'
'K'
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
4.2.2 集合相关处理函数
函数名称作用
intersection(set)获取原集合与set的交集
&同上
union(set)获取原集合与set的并集
|同上
difference(set)获取原集合与set的差集
-同上
symmetric_difference(set)获取原集合与set异或集(仅在两个集合中出现一次)
^同上
issubset(set)判断原集合是否为set的子集
<=同上
<判断真子集
issuperset(set)判断原集合是否为set的超集
>=同上
>判断真超集

总结

  • 到此为止,关于元组、列表、字典、集合的常用相关基础知识已经全部敲出来了,说实话这些东西看的时候可能一个小时就能看完,但是要敲出来得需要一天,不过在敲的过程中确实加强了很多,毕竟那些举得例子大多需要在解释器里运行一下,有时候出个错也能更掌握相关知识点,这篇文章对我自己肯定有帮助,希望也能帮到看到的你。
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/寸_铁/article/detail/836816
推荐阅读
相关标签
  

闽ICP备14008679号