Python中字典和列表的组合 python中列表与字典的区别

目录

前言：

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

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

1、列表的定义：

2、元组的定义：

3、字典的定义：

4、集合的定义：

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

1、列表的方法：

2、元组的方法：

3、字典的方法：

4、集合的方法：

四、列表、元组、字典、集合之间的比较：

1、元组和列表区别

2、字典和列表区别

3、集合和字典的区别

五、推导式创建序列：

1、列表推导式，语法如下：

2、字典推导式，语法如下：

3、集合推导式，语法如下：

4、元组没有推导式：

前言：

面试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里

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:\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-13-3f824745aed8>", line 1, in <module>
    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()

四、列表、元组、字典、集合之间的比较：

1、元组和列表区别

• 元组比列表操作速度快； 
• 元组对数据“写保护“ ；
• 元组可用于字符串格式化中 ；
• 元组可作为字典的key；

2、字典和列表区别

• 字典的查找和插入的速度极快，不会随着key的增加而增加 ；
• 但是字典需要占用大量的内存，内存浪费多； 
• 列表的查找和插入的时间随着元素的增加而增加；
• 但是列表的占用空间小，浪费内存很少； 
• 所以，dict是用空间来换取时间的一种方法。

3、集合和字典的区别

• 集合和字典的唯一区别仅在于没有存储对应的value； 
• 结合和字典的原理一样，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。

五、推导式创建序列：

        推导式是从一个或者多个迭代器快速创建序列的一种方法。它可以将循环和条件判断结合，从而避免冗长的代码。推导式是典型的 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、元组没有推导式：