列表&字典&集合内置方法

列表数据类型内置方法

作用

描述多个值，比如爱好等

定义方式

hobby_list = ['sing', 'dance', 'rap', 'basketball']

lt = list('cxk')

print(lt)	#结果为['c', 'x', 'k']

内置方法

索引取值（以下必须掌握）

列表可进行索引修改，索引类似于字符串，第一个值为0，往后依次推类。也可以从最后一个值-1开始往前依次推类

索引修改则要找到对应的值之后再进行修改

hobby_list = ['sing', 'dance', 'rap', 'basketball']

print(1, hobby_list[-1])
hobby_list[-1] = '233'  # 索引修改
print(2, hobby_list[-1])

结果为：

1 basketball
2 233

切片

列表的切片也类似于字符串，这里就不多bb了，直接贴上代码就能看懂了

（注意，每次在运行代码时要重新赋值，因为每次调用内置函数都会改变列表本身）

print(hobby_list[:])  
print(hobby_list[::-1])		#-1位反序  
print(hobby_list[0:3:2])

结果为：

['sing', 'dance', 'rap', 'basketball']
['basketball', 'rap', 'dance', 'sing']
['sing', 'rap']

长度

可以得出该列表一共有几个值

print(len(hobby_list))

in/not in

和字符串一样，正确返回true，错误返回false

print('sing' in hobby_list)  # True
print('play' in hobby_list)  # False

for循环

可以遍历列表得出其中的值

for hobby in hobby_list:
    print(hobby)

结果为：

sing
dance
rap
basketball

del删除

顾名思义，根据索引值删除值

del hobby_list[-1]
print(hobby_list)

结果为“

['sing', 'dance', 'rap']

append追加

可在列表的最后追加一个值

hobby_list.append('我吐辣')
print(hobby_list)

结果为：

['sing', 'dance', 'rap', 'basketball', '我吐辣']

count计数（以下需要掌握）

count可以对列表内的某个元素计数

hobby_list = ['sing', 'dance', 'rap', 'basketball', '233', '233']
print(hobby_list.count('233')) # 结果为：2

extend扩展列表

和append区别：append追加一个值，extend扩展一个列表

hobby_list.extend([1, 2, 3, 4])  
print(hobby_list)

结果为：

['sing', 'dance', 'rap', 'basketball', 1, 2, 3, 4]

clear清除

将整个列表清除

hobby_list.clear()  # 清除
print(hobby_list)	# 结果为：[]

copy复制

可以保存改动之前的列表

hobby_list2 = hobby_list.copy()  # 复制列表

hobby_list[-1] = '233'
print(hobby_list)		# ['sing', 'dance', 'rap', '233']
print(hobby_list2)		# ['sing', 'dance', 'rap', 'basketball']

在某些特定的情况用处很大，比如每次去掉列表中最后一个值的时候，如果不用copy是这样的：

lis = [1, 2, 3, 4, 5] 
#
# lis2 = lis.copy()
for i in lis:  
    lis.pop()
    print(lis)

看上去好像没有什么问题吧，可是 你运行代码就会发现，结果和你想象的不同

[1, 2, 3, 4]
[1, 2, 3]
[1, 2]

怎么会这样呢，因为列表和字符串不同，列表是可变的，每次你删除一个值，列表的值的数量就会少1，当i的值还没达到要求，就已经大于列表值的数量，也就是循环结束的最大值了。所以，才会出现这种情况。但是如果加上copy就不回了：

lis = [1, 2, 3, 4, 5]  # [1,2]
for i in lis.copy():  # [1,2,3,4,5]  # [1,2,3,4]  # [1,2,3]  # i = 3
    lis.pop()
    print(lis)

结果为：

1, 2, 3, 4]
[1, 2, 3]
[1, 2]
[1]
[]

pop/remove删除

pop默认删最后一个

remove则可以指定想要删除的值

hobby_list.pop()  
print(hobby_list)
hobby_list.remove('sing')  
print(hobby_list)

结果为：

['sing', 'dance', 'rap']

['dance', 'rap', 'basketball']

index

索引，输入值可知道对应的索引，如果没有则会报错

print(hobby_list.index('dance'))
print(hobby_list.index('dance', 0, 2))  # 索引0-2内有没有该值

结果为：1

​ 1

insert插入

插入需要输入对应的索引，随后列表内原本索引会全部往后退一格

hobby_list.insert(0, '1')  # 插入
print(hobby_list)

结果为：['1', 'sing', 'dance', 'rap', 'basketball']

reverse反转

可以将列表里的值反过来

hobby_list.reverse()  # 反转
print(hobby_list)

结果为：['basketball', 'rap', 'dance', 'sing']

sort排序

排序的列表中只能单独存在字符串和数字，否则无法比较

lis = [2, 1, 4, 3, 5]
lis.sort()
print(lis)

结果为：[1, 2, 3, 4, 5]

存在一个值还是多个值

多个值

有序or无序

有序

可变or不可变

可变

元组

定义方式

列表中的括号改为小括号

元组类似于列表，但是元组无法被修改，元组在定义的那一刻他的元素个数以及元素的值全部固定了

lis = [1,2,3,4]
tup = (1,2,3,4)
print(tup[1]) # 2
lis[1] = 5
print(lis)	# [1,3,3,4]
tup[1] = 5
print(tup)	# 报错

毫无用处，早期元组一般用于减小内存占用，以后只要定义列表就行了

存在一个值还是多个值

多个值

有序or无序

有序

可变or不可变

压根没有这一说法

字典

作用

对于值添加描述信息使用它

定义方式

用{ }以逗号隔开加入键值对key：value

info_dict = {'name' : 'cxk', 'gender' : 'none' , 'hobby_list' : ['sing', 'dance', 'rap', 'basketball']}

内置方法

以下一些和字符串及列表重复的内置方法我就直接跳过了，看看代码就好了

取值方式（以下必须掌握）

按键取值，即可取也可变（以下必须掌握）

print(info_dict['hobby_list'])
info_dict['age'] = 20
print(info_dict)

结果为：

['sing', 'dance', 'rap', 'basketball']
{'name': 'cxk', 'gender': 'none', 'hobby_list': ['sing', 'dance', 'rap', 'basketball'], 'age': 20}

长度

print(len(info_dict))	# 3

in or not in

print('name' in info_dict)	# True

for循环

只能取键，取值的方法下面会讲到

for i in info_dict:
    print(i)

结果为：

name
gender
hobby_list

keys/values/items

可以取出相应的值

print(list(info_dict.keys()))  # list
print(list(info_dict.values()))  # list
print(list(info_dict.items()))  # list
print(info_dict.items())

结果为：

['name', 'gender', 'hobby_list']
['cxk', 'none', ['sing', 'dance', 'rap', 'basketball']]
[('name', 'cxk'), ('gender', 'none'), ('hobby_list', ['sing', 'dance', 'rap', 'basketball'])]

dict_items([('name', 'cxk'), ('gender', 'none'), ('hobby_list', ['sing', 'dance', 'rap', 'basketball'])])

配合for循环可以取键，取值，或者俩个都取

for i in info_dict.values():
    print(i)

结果为：

cxk
none
['sing', 'dance', 'rap', 'basketball']

其中items用的最多，一般和解压缩一起用

for i in info_dict.items():
    print(i)

for k, v in info_dict.items():
    print(k, v)

结果为：

('name', 'cxk')
('gender', 'none')
('hobby_list', ['sing', 'dance', 'rap', 'basketball'])
name cxk
gender none
hobby_list ['sing', 'dance', 'rap', 'basketball']

copy（以下需要掌握）

可以复制整个字典，类似于列表

pop/popitem

pop删除指定key值的键值对

popitem 早期的时候字典是无序的，是随机删除的，但是由于Python3优化了字典，让字典看起来貌似有序了

info_dict.pop('name')
print(info_dict)

info_dict.popitem()  
print(info_dict)

结果为：（因为是可变的，所以最后一行的输出是在上次的基础上运行的）

{'gender': 'none', 'hobby_list': ['sing', 'dance', 'rap', 'basketball']}
{'gender': 'none'}

clear

清除该字典

info_dict.clear()
print(info_dict)	# {}

get

如果有则返回字典中的值，没有返回none（默认），或者自己想要的值，不会报错

print(info_dict.get('age'))
# print(info_dict['name'])
print(info_dict.get('name', 'nick'))  # 如果有,就返回真正的值;如果没有,默认返回None,也可以指定返回

结果为：

None
cxk

setdefault

往里面追加的值，如果key已存在，则不变

info_dict.setdefault('age', 123123)

结果为：{'name': 'cxk', 'gender': 'none', 'hobby_list': ['sing', 'dance', 'rap', 'basketball'], 'age': 123123}

update更新

如果已有key则更改所对应的值，如果没有则增加一个值

info_dict.update({'age':123})
print(info_dict)
info_dict.update({'name':1})
print(info_dict)

结果为：

{'name': 'cxk', 'gender': 'none', 'hobby_list': ['sing', 'dance', 'rap', 'basketball'], 'age': 123}
{'name': 1, 'gender': 'none', 'hobby_list': ['sing', 'dance', 'rap', 'basketball'], 'age': 123}

fromkeys

由dict.出来，快速造一个字典

print(dict.fromkeys(['a',2,3,4,5],'hyc'))

结果为：{'a': 'hyc', 2: 'hyc', 3: 'hyc', 4: 'hyc', 5: 'hyc'}

看上去好像很牛逼，实际上卵用没有

存在一个值还是多个值

多个值

有序or无序

无序

可变or不可变

可变

集合

基本用不到，Redis

作用

就是存储一大堆元素的东西，容器数据类型

定义方式

以{}用逗号隔开不可变数据类型

s = {1, 2, 1, 'a', 'a', 'c'}

去重（用的到）可将列表中相同的元素去除

lis = [1,2,3,1,3]
print(set(lis))
print(list(set(lis)))

结果为：

{1, 2, 3}

[1, 2, 3]

乱序

顾名思义，集合中的元素顺序是乱的，即每次运行顺序都不同

注意，{}表示的是字典，不是集合，定义空集合必须用set()

内置方法

可将俩个集合实现并集，交集，差集，交叉补集

pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}  # 定义俩个集合

print(pythoners | linuxers)  # 并集
print(pythoners.union(linuxers))

print(pythoners & linuxers)  # 交集
print(pythoners.intersection(linuxers))

print(pythoners - linuxers)  # 差集
print(pythoners.difference(linuxers))

print(pythoners ^ linuxers) # 交叉补集
print(pythoners.symmetric_difference(linuxers))

结果为：

{'tank', 'sean', 'nick', 'jason', 'kevin', 'egon'}
{'tank', 'sean', 'nick', 'jason', 'kevin', 'egon'}
{'nick'}
{'nick'}
{'jason', 'tank', 'sean'}
{'jason', 'tank', 'sean'}
{'tank', 'sean', 'jason', 'egon', 'kevin'}
{'tank', 'sean', 'jason', 'egon', 'kevin'}

add增加

s = {1,2,3}
s.add(4)
print(s)	# {1, 2, 3, 4}

pop随即删除

使用s.pop(会随机删除一个元素

clear

清空该集合

copy复制

复制该集合

remove/discard

remove没有则报错，而discard没有不报错

存在一个值还是多个值

多个值

有序or无序

无序

可变or不可变

可变

虽然这一次看上去很多，但总体来说只要熟练运用各种内置方法，相信今天的内容也可以快速掌握了