目录

前言：

1.以表格的形式显示它们的差异：

2.列表、元组、词典、集合的定义区分：

1列表的定义：

2元组的定义：

3词典的定义：

4集合的定义：

3.列表、元组、词典、集合的方法(函数)：

1，List方法：

2，元组方法：

3，字典方法：

4、收集方法：

4.列表、元组、词典、集合之间的比较：

1、元组和列表差异

2、词典和列表差异

3集合和词典之间的区别。

5.派生创建序列：

1，列表派生，语法如下：

2，词典派生，语法如下：

3，设置派生，语法如下：

4，不带派生的元组：

前言：

面试Python届时，如果把列表、元组、词典、集合的区别讲清楚，基本知识点就能反映面试官的基本水平，一定会给面试官留下好印象。我们开始详细说明它们之间的区别。

1.以表格的形式显示它们的差异：

列表

元组

字典

集合

英文

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]

无

2.列表、元组、词典、集合的定义区分：

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))
# 
t2 = (天坛)
t3 = (颐和园,) # 当元组中只有一个元素时，需要添加逗号，否则Python解释器将其视为字符串。
print(type(t2), type(t3))
#  

3词典的定义：

字典是一个变量容器模型，可以存储任何类型的对象。元素的关键字(key）和值（value)由键-值对组成。 ，元素用逗号“，”分隔，键和值用冒号分隔。
键必须是不变的和唯一的，例如字符串、数字或元组，但值可以重复，值可以采用任何数据类型。Python“中的元组”{}”表示：

d_dict = {1: a, 2: b, 3: c}
print(type(d_dict))
# 

4集合的定义：

与字典类似，它只包含键，不包含对应值，并且不包含重复数据。

s_set = {1, 2, 3}
print(type(s_set))
# 

3.列表、元组、词典、集合的方法(函数)：

1，List方法：

方法(函数)

作用

具体方法说明

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:ProgramDataAnaconda3libsite-packagesIPythoncoreinteractiveshell.py", line 2961, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "", line 1, in 

(5.)pop()删除指定的键值对，返回对应的Value Object

(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)          #计算词典元素的数量，即E。密钥的总数。
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里

4、收集方法：

s1 ={3, 8, apple, dog}
# 确定元素是否在集合中
apple in s1
# Out[4]: True
banana in s1
# Out[5]: False
# 向集合中添加一个值，如果该值存在，则不执行任何操作。
s1.add(cat)
s1
# Out[8]: {3, 8, apple, cat, dog}
# 删除元素
s1.remove(8)
s1
Out[12]: {3, apple, cat, dog}
s1.remove(0) # 如果元素不存在，则会出现错误。
Traceback (most recent call last):
  File "D:ProgramDataAnaconda3libsite-packagesIPythoncoreinteractiveshell.py", line 2961, in run_code
    exec(code_obj, self.user_global_ns, self.user_ns)
  File "", line 1, in 
    s1.remove(0)
KeyError: 0
# 这样，如果元素不存在，也不会发生错误。
s1.discard(2)
s1
# Out[15]: {3, apple, cat, dog}
# 计算集合中的元素数量
len(s1)
# Out[17]: 4
#清空集合
s1.clear()
s1
# Out[20]: set()

4.列表、元组、词典、集合之间的比较：

1、元组和列表差异

• 元组运算速度比列表运算快；
• 元组到数据的“写保护” ；
• 可以在字符串格式中使用元组。 ；
• 元组可以用作词典。key；

2、词典和列表差异

• 词典查找和插入非常快，并且不会跟随。key增加，再增加。 ；
• 然而，词典需要占用大量内存，浪费大量内存；
• 列表的查找和插入的时间随着元素增加，再增加。；
• 然而，列表占用的空间很小，浪费的内存也很少；
• 所以，dict这是一种用空间换取时间的方式。

3集合和词典之间的区别。

• 集合和词典之间的唯一区别是没有对应的value；
• 与字典相同的原理是，不能将相同的东西放入变量对象中，因为不可能确定两个变量对象是否相等，也没有保证。set内部“无重复元素”。

5.派生创建序列：

派生是一种从一个或多个迭代器快速创建序列的方法。它可以组合循环和条件判断，以避免冗长的代码。派生出的是典型的 Python 风格。

1，列表派生，语法如下：

• [表达式foritemin 可迭代对象 ]或者：[表达式foritemin 可迭代对象if条件判断]

  [x for x in range(0,10)] Out[21]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [x for x in range(1,20) if x%5==0] Out[22]: [5, 10, 15] cells = [(row,col) for row in range(0,5) for col in range(11,15)] # 多个for循环 for cell in cells: print(cell)

2，词典派生，语法如下：

• {key_expression:value_expressionfor表达式in可迭代对象}与列表派生类似，也可以增加字典派生。 if 有条件的判决，多重的 for 循环。

计算文本中的字符数：

text =  i love you, i love china, i love niuniuxiaoai
char_count = {c:text.count(c) for c in text}
char_count

3，设置派生，语法如下：

• {表达式foritemin 可迭代对象 }或者：{表达式foritemin 可迭代对象if条件判断}

  {x for x in range(1,100) if x%9==0}

  Out[28]: {9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99}

4，不带派生的元组：