面试Python必会的的基础知识：列表、元组、字典、集合的区别

最新推荐文章于 2024-02-02 05:00:00 发布

lanxingbudui

最新推荐文章于 2024-02-02 05:00:00 发布

阅读量4.4k

点赞数 6

分类专栏： Python 小白学Python 文章标签： python 列表元组字典推导式

本文链接：https://blog.csdn.net/lanxingbudui/article/details/108720324

版权

Python 同时被 2 个专栏收录

15 篇文章 6 订阅

订阅专栏

小白学Python

10 篇文章 5 订阅

订阅专栏

三、列表、元组、字典、集合的方法（函数）：

前言：

面试Python时，如果把列表、元组、字典以及集合之间的区别，这个基础的知识点讲解清楚，就能反映出面试者的基础水平，也必定会给面试官一个很好的印象。我们开始来阐述他们区别。

一、以表格的形式展示他们的区别：

	列表	元组	字典	集合
英文	list	tuple	dict	set
是否可读写	读写	只读	读写	读写
是否可重复	可以	可以	可以	不可以
存储方式	值	值	键值对（键不可以重复）	键（不能重复）
是否有序	有序	有序	无序，自动正序	无序
初始化	[1, 'aa']	('aa', 'bb')	{‘a’: 1, 'b': 2}	set([1, 2])或{‘a’, 'b'}
添加	append	只读	d[key] = 'value'	add
读元素	l[1]	t[1]	d['a']	无

二、列表、元组、字典、集合的定义区分：

1、列表的定义：

list是存储在方括号中的一组有序元素的数据结构，列表中的元素是可以添加、修改、删除、还可以查询其中的元素。列表是可变、可嵌套的数据类型。python里的列表用“[]”表示：

test_list = [1, 2, 3, 4]
print(test_list[0]) # 搜素其中某一项
# 1
test_list[1] = 'aa' # 修改某一项
print(test_list)
# [1, 'aa', 3, 4]
test_list.append('花花') # 添加一项
print(test_list)
# [1, 'aa', 3, 4, '花花']
test_list.extend('华晨宇') # 添加一项
print(test_list)
# [1, 'aa', 3, 4, '花花', '华', '晨', '宇']

2、元组的定义：

元组和列表类似，是存储在圆括号中一组有序不可修改的元素的序列，只可查询其中的元素。通常情况下，元组用于保存无需修改的内容。Python里的元组用“()”表示：
需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号‘,’，否则 Python 解释器会将它视为字符串。

t_tuple = ('故宫', '长城', '香山')
t_tuple
# ('故宫', '长城', '香山')
print(type(t_tuple))
# <class 'tuple'>
t2 = ('天坛')
t3 = ('颐和园',) # 当元组中只有一个元素时，需要加一个逗号，否则Python解释器认为是字符串。
print(type(t2), type(t3))
# <class 'str'> <class 'tuple'>

3、字典的定义：

字典是一种可变的容器模型，且可存储任意类型的对象。元素由键（key）和值（value）组成的键值对，元素之间用逗号“，”分隔，键与值之间用冒号“：”隔开。
键必须是不可变且唯一的，如字符串，数字或元组，但值可以重复，值可以取任何数据类型。Python里的元组用“{}”表示：

d_dict = {1: 'a', 2: 'b', 3: 'c'}
print(type(d_dict))
# <class 'dict'>

4、集合的定义：

与字典类似，但只包含键，而没有对应的值，包含的数据不重复。

s_set = {1, 2, 3}
print(type(s_set))
# <class 'set'>

三、列表、元组、字典、集合的方法（函数）：

1、列表的方法：

方法（函数）	作用	具体的方法描述
list.append(x)	增加元素	将元素x增加到列表list尾部
list.extend(alist)	增加元素	将列表alist所有元素增加到列表list尾部
list.insert(index,x)	增加元素	将列表list指定位置index处插入元素x
list.remove()	删除元素	在列表list中删除首次出现的指定元素x
list.pop([index])	删除元素	删除并返回列表list指定位置index处的元素，默认是最后一个元素
list.clear()	删除所有元素	删除列表list中所有元素，并不是删除列表对象
list.count(x)	计数	返回指定元素x在列表list中出现的次数
len(list)	列表长度	返回列表中包含元素的个数
list.reverse()	翻转列表	所有元素原地翻转
list.sort()	排序	所有元素原地排序
list.copy()	浅拷贝	返回列表对象的浅拷贝

举例说明：

t_list = [1, 2]
t_list.append('python')  # append()函数是1个参数，为要添加的元素。
t_list
# [1, 2, 'python']
t_list.extend(['java', 'go'])  # extend()函数也是1个参数，可以多个元素，但是必须写成列表的形式。
t_list
# [1, 2, 'python', 'java', 'go']
t_list.insert(1, 'linux')
t_list
#  [1, 'linux', 2, 'python', 'java', 'go']
t_list.remove(2)
t_list
#  [1, 'linux', 'python', 'java', 'go']
t_list.pop()
# 'go'
t_list
# [1, 'linux', 'python', 'java']
t_list.pop(0)
Out[13]: 1
t_list
Out[14]: ['linux', 'python', 'java']
t_list.clear()
t_list
# []

my_list = [1, 2, 3, 'a', 'b', 'c', 1, 2, 3]
my_list.count(3)
# 2
len(my_list)
# 9
my_list.reverse()
my_list
# [3, 2, 1, 'c', 'b', 'a', 3, 2, 1]
list1 = [1, 5, 3, 6, 2]
list1.sort()  # sort()排序时要保证列表是相同类型的元素，否则无法比较大小而排序。
list1
# [1, 2, 3, 5, 6]
list2 = list1.copy()  # copy()浅拷贝是只复制数值，不复制框架、类等。
print(list2)
[1, 2, 3, 5, 6]

2、元组的方法：

(1.)创建元组：

t_1 = ('故宫', '长城', '香山')
t_2 = ('颐和园',) # 当元组中只有一个元素时，需要加一个逗号，否则Python解释器认为是字符串。

(2.)合并元组：

t_1 = ('故宫', '长城', '香山')
t_2 = ('颐和园',)
t_3 = t_1 + t_2
t_3
#  ('故宫', '长城', '香山', '颐和园')

(3.)删除元组：（t_3已经删除不存在，所有报错）

注：元组的基本操作与列表的操作一致，除了不能修改元组本身外。

3、字典的方法：

(1.)字典的创建：

dict1 = {'a': 12, 'b': 16, 'b': 18}
dict1
# {'a': 12, 'b': 18}  # 因为键存在相同，所以后面的键值替换了前面的键值

(2.)访问字典中的值：

(3.)修改字典：

dict1['a'] = 666
dict1
# {'a': 666, 'b': 18}

(4.)删除字典元素，能删单一的元素也能清空字典，并且可以直接删除字典：

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict1
# {'a': 1, 'b': 2, 'c': 3}
del dict1['b']
dict1
# {'a': 1, 'c': 3}
dict1.clear()
dict1
# {}
del dict1
dict1
Traceback (most recent call last):
  File "D:\ProgramData\Anaconda3\lib\site-packages\IPython\core\interactiveshell.py", line 2961, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "<ipython-input-35-e36219336d90>", line 1, in <module>

(5.)pop()删除指定键值对，并返回对应的“值对象”

(6.)popitem() ：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念；popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）。

a = {1: 'aaa', 2: 'bbb', 3: 'ccc', 4: 'ddd', 5: 'eee'}
print(a)
# {1: 'aaa', 2: 'bbb', 3: 'ccc', 4: 'ddd', 5: 'eee'}
a.pop(2)
# Out[13]: 'bbb'
print(a)
# {1: 'aaa', 3: 'ccc', 4: 'ddd', 5: 'eee'}
print(a.popitem())
# (5, 'eee')
print(a)
# {1: 'aaa', 3: 'ccc', 4: 'ddd'}

(7)Python字典包含了以下内置函数：

cmp(dict1, dict2)  #比较两个字典元素。
len(dict)          #计算字典元素个数，即键的总数。
str(dict)          #输出字典可打印的字符串表示。
type(variable)     #返回输入的变量类型，如果变量是字典就返回字典类型。

(8)Python字典包含了以下内置方法：

dict.clear()                         #删除字典内所有元素
dict.copy()                          #返回一个字典的浅复制
radiansdict.fromkeys()               #创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
dict.get(key, default=None)  　　　   #返回指定键的值，如果值不在字典中返回default值
dict.has_key(key)            　　　   #如果键在字典dict里返回true，否则返回false
dict.items()					     #以列表返回可遍历的(键, 值) 元组数组
dict.keys()    　　　　　　　　　　    #以列表返回一个字典所有的键
dict.values()    　　　　　　         #以列表返回字典中的所有值
dict.setdefault(key, default=None)   #和get()类似, 但如果键不已经存在于字典中，将会添加键并将值设为default
dict.update(dict2)     　　　         #把字典dict2的键/值对更新到dict里