[Python知识库]Python列表、元组、字典、集合

列表

? 在python中用[ ]表示一个列表。

索引和切片

? 列表中使用的索引和切片类似于字符串中的（从零开始，包左不包右）这里不过多解释，介绍两种稍微特殊点的表达方式。

a=['you','are','the','best']
a[3][0:2]
输出为：
’bes‘

? a[3][2]表示的是对列表进行两次切片。第一个[ ]的含义是取出列表中第几个元素，第二个[ ]的含义是对取出的元素进行进一步切片处理。

a=['you','are','the','best']
a[-3:-1]
输出为：
['are','the']//仍然满足含左不含右
a[-1:-3]
输出为：
空

? 列表从右编号时，右边第一个就是-1号，从右往左依次降低。在列表中序列都是从左往右读取的。所以当列表的索引是负数时a[-1:-3]，表示的是从右往左所以输出为空。

列表操作方法

? len()求长度

? "+"连接两序列

? “*”重复

? in 判断元素是否在列表中

? max()、min()返回列表中最大、最小的元素

a.append(b) 将某个元素x加入到列表的最右侧。将b中的元素整体加入到a中。append()函数修改列表是在原地修改的，即没有产生变量占用其他内存。

>>> a=['you','are','the','best']
>>> b='NO.1'
>>> a.append(b)
>>> print(a)
['you', 'are', 'the', 'best', 'NO.1']

>>> a=['you','are']
>>> b=['the','best']
>>> a.append(b)
>>> print(a)
['you', 'are', ['the', 'best']]

a.extend(b)将b中的所有元素加入到a中，让a扩容。 (将b中的元素个体化然后添加到a中实现对a的扩容)。extend()也是在原地修改列表的。

>>> a=['you','are','the','best']
>>> b='NO.1'
>>> a.extend(b)
>>> print(a)
['you', 'are', 'the', 'best', 'N', 'O', '.', '1']

>>> a=['you','are']
>>> b=['the','best']
>>> a.extend(b)
>>> print(a)
['you', 'are', 'the', 'best']

? a.count(b)在列表a中查找b出现的次数。

? a.index(b)查找b在a中的位置。若不存在就报错，若出现多次，返回值为第一次出现的位置。

>>> a=['you','are','the','best']
>>> a.index('the')
2
>>> a.index('who')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 'who' is not in list
>>> c=[1,2,3,4,5,5,6,4,5]
>>> c.index(5)
4

? insert() 上述介绍的append()和extend()函数只能在列表的最右边添加元素。insert()能够在任意位置添加元素。a.insert(i,b) 在列表a的第i个位置添加b

? a.remove(b)从列表a中删除b 如果b没有在a中那么报错，如果b在a中那么在原地删除b。如果有多个b那么删除第一个b。

a.pop([i])从列表a中删除第i个元素，并将这个删除的元素作为返回值返回。a.pop()默认的是删除最后一个元素。当i超出索引时报错。

reverse()将列表中的元素顺序反转。原地操作而不是生成一个新的列表（什么是新的列表？在原来位置的列表发生变化，这种情况不是生成新的列表。举个例子：一个人一个坑，人换了坑还是那个坑，只是人不同了。当生成的列表占用其他位置时，就是产生了新的列表），所以没有返回值。

多维列表

>>> a=[[1,2,3],[4,5,6],[7,8,9]]//矩阵
>>> a[1][1]
5
>>> b=[[1,2,3],[4,5,6],7,8]
>>> b[2][1]//超出搜索范围
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not subscriptable
>>> b[1][1]
5
>>> b[2]//元素7的索引
7
>>> b[0]
[1, 2, 3]

元组

? ?元组中的元素是任意类型的Python对象。元组使用圆括号括起来的，其中的元素之间用逗号(英文半角)隔开。

（, , , ）

举例：

>>> a = 'i',521,['Python']
>>> a
('i', 521, ['Python'])

? 元组上的索引与列表、字符串相似不在介绍。

?值得注意的是元组是不可修改的，里面的元素都是确定的无法更改。

元组与列表是互通的通过list（）和tuple（）两者可以相互转化。

>>> a = 'i',521,['Python']
>>> a
('i', 521, ['Python'])
>>> b=list(a)
>>> b
['i', 521, ['Python']]
>>> c=tuple(b)
>>> c
('i', 521, ['Python'])

字典

? 字典使用花括号括起来，有多个键值对组成 键：值每对键值对之间用逗号（英文半角）隔开。在字典中键是无法改变的数据类型，值是可以任意改变的。

1、如何生成字典

直接生成

>>> person = {'name':'wang','subject':'python'}
>>> person
{'name': 'wang', 'subject': 'python'}
>>> person['time']='2021'
>>> person
{'name': 'wang', 'subject': 'python', 'time': '2021'}

?利用元组来生成字典

>>> a=(['name','wang'],['subject','python'])
>>> b=dict(a)
>>> b
{'name': 'wang', 'subject': 'python'}

2、如何访问字典

? 字典类型对象是通过键值对的形式来储存数据的，所以只要知道了键，就能够得到值。

>>> person = {'name':'wang','subject':'python'}
>>> person['name']
'wang'

3、对字典的操作

假设person是一个字典

len(person)返回字典person中的键值对的数量。

person[key1] 返回字典person中键key1对应的值

person[key1]=value1 将键key1对应的值改变为value1

del person[key1] 删除字典person中key1d对应的键值对

key1 in person检查key1是否在字典person中。

浅拷贝和深拷贝

在讲这部分之前举个例子：

>>> person = {'name':'wang','subject':'python'}
>>> people = person
>>> id(person)
2560301114432
>>> id(people)
2560301114432
>>> person['name']='zhang'
>>> person
{'name': 'zhang', 'subject': 'python'}
>>> people
{'name': 'zhang', 'subject': 'python'}

对象有类型，变量无类型，变量就是一个标签?通过上述操作我们可以发现1的位置只有一个，a、b不过是给1这个对象贴上了两个标签而已。这种赋值的方式也叫做“假装拷贝”。

在python中使用copy（）函数可以实现浅拷贝，什么是浅拷贝呢？举个例子：

>>> person = {'name':'wang','subject':'python'}
>>> people=person.copy()
>>> id(person)
2420231152832
>>> id(people)
2420231153024
>>> person['name']='zhang'
>>> person
{'name': 'zhang', 'subject': 'python'}
>>> people
{'name': 'wang', 'subject': 'python'}

? 使用copy（）函数就可以产生一个新的id去储存这个变量。在两个不同的坑里，彼此互不相干，修改person中的值，people中的值不会发生变化。

cope（）函数实现了划分新的id储存变量克服了假拷贝的缺点，那为什么叫做浅拷贝呢？举个例子：

>>> a={'name':['wang','zhang'],'subject':'python'}
>>> b=a.copy()
>>> a['name'][0]='liu'
>>> a
{'name': ['liu', 'zhang'], 'subject': 'python'}
>>> b
{'name': ['liu', 'zhang'], 'subject': 'python'}
>>> a['subject']='java'
>>> a
{'name': ['liu', 'zhang'], 'subject': 'java'}
>>> b
{'name': ['liu', 'zhang'], 'subject': 'python'}
>>> id(a['name'])
2560301212416
>>> id(b['name'])
2560301212416
>>> id(a['subject'])
2560301140528
>>> id(b['subject'])
2560301493360

使用了函数copy（）为什么更改a中的值b中的值也发生了变化呢？ 通过调用id我们就可以发现其中的原因。这是因为在使用copy（）时，列表这类由字符串、数字等复合而成的对象仍然是复制了引用，没有建立一个新的对象，所以这时要引入一个“深拷贝”来解决这个事情。

? 在python中要使用“深拷贝”，需要先引用一个模块。

>>> import copy
>>> a={'name':['wang','zhang'],'subject':'python'}
>>> b=copy.deepcopy(a)
>>> a['name'][0]='liu'
>>> a
{'name': ['liu', 'zhang'], 'subject': 'python'}
>>> b
{'name': ['wang', 'zhang'], 'subject': 'python'}

集合

如何创建集合：

set（）

>>> a=set('person')
>>> a
{'p', 's', 'n', 'o', 'e', 'r'}

set建立起来的集合都是可变集合。