列表、字典、元组、集合的内置方法
今天一整天都没有拉屎，我很难受，一点状态都没有
还好学习没有阻塞。
今天的憨憨们有没有给自己打气呀，上图
每天都要相信自己，一定要有相信的东西。
今日洗脑金句： 心若不狠，战意不稳，天天狂刷题，心停手不停。
一、列表类型内置方法
1.用途：多个东西，什么东西呢，多个女朋友啊，多个男朋友啊，多个乱七八糟的。
2.定义：[]内可以有多个任意类型的值，用逗号分隔每个元素
my_girl_friend = ['韩红', '凤姐', '钟源']
print(f"my_girl_friend: {my_girl_friend}")
my_girl_friend: ['韩红', '凤姐', '钟源']
就这么回事，可以通过索引来取值，之前都讲过很多次了，你在不懂我就生气了。
1.1优先掌握
- 按索引取值（正向取值+反向取值），即可存也可以取
- 切片
- 长度len
- 成员运算in和not in
- 追加append
- 删除del
- 循环
1.按索引取值(正向取值+反向取值)，即可以存也可以取
# list之索引取值
name_list = ['力哥', 'jason', 'tank', 'sean']
name_list[0] = '力哥 炸帅'
# name_list[1000] = 'tank sb' # 报错
print(f"name_list[0]: {name_list[0]}")
name_list[0]: 力哥 炸帅
2.切片
# list之切片
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"name_list[0:3:2]: {name_list[0:3:2]}")
name_list[0:3:2]: ['nick', 'tank']
这个方法和字符串一样儿一样儿的，一毛一样，对。
3.长度
# list之长度
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"len(name_list): {len(name_list)}")
len(name_list): 4
都是基本操作
4.成员运算in和not in
# list之成员运算in和not in
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"'tank sb' in name_list: {'tank sb' in name_list}")
print(f"'nick handsome' not in name_list: {'nick handsome' not in name_list}")
'tank sb' in name_list: False
'nick handsome' not in name_list: True
基本基本~
5.追加值
# list之追加值
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.append('tank sb')
print(f"name_list: {name_list}")
name_list: ['nick', 'jason', 'tank', 'sean', 'tank sb']
这个就是列表独有的内置方法了，这个方法有点好用哦，他是什么意思呢，就是你在这个方法体内写入一个参数，就会被追加到调用这个方法的对象的屁股上去，对，最后，屁股的位置.jpg)
6.删除
# list之删除
name_list = ['nick', 'jason', 'tank', 'sean']
del name_list[2]
print(f"name_list: {name_list}")
name_list: ['nick', 'jason', 'sean']
同样的，基本操作，注意，这是通过索引来删除的，如果你的索引超过了他的范围，就会报错。
7.循环
# list之循环
name_list = ['nick', 'jason', 'tank', 'sean']
for name in name_list:
print(name)
nick
jason
tank
sean
1.2需要掌握
- insert
- pop
- remove
- count
- index
- clear
- copy
- extend
- reverse
- sort
好了让我们来看看这些需要掌握的方法都是些什么玩意儿
1.insert()
# list之insert()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.insert(1, 'handsome')
print(f"name_list: {name_list}")
name_list: ['nick', 'handsome', 'jason', 'tank', 'sean']
音色特方法，插入一个数据，这可不是随便插哦，这个要找对地方插（斜眼笑），你要明确要插入数据的索引， 诶有人就开始bb了，’那个索引上已经有数据了呢？‘，有数据了就让他往后稍稍啊，插，什么是插，插队啊，后面所有数据的索引值全都加1
下一题！
2.pop()
# list之pop()，pop()默认删除最后一个元素
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"name_list.pop(1): {name_list.pop(1)}")
print(f"name_list: {name_list}")
name_list.pop(1): jason
name_list: ['nick', 'tank', 'sean']
和del的区别在哪里，有，你不写索引的话默认删除最后一个，并且他有返回值，就是被删除的元素。
3.remove()
# list之remove()
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"name_list.remove('nick'): {name_list.remove('nick')}")
print(f"name_list: {name_list}")
name_list.remove('nick'): None
name_list: ['jason', 'tank', 'sean']
remove方法呢，他也有返回值，他会在删除成功后返回一个None，如果删除的对象不存在会报错，通过数据来删除，而不是通过索引了。
4.count()
# list之count()
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"name_list.count('nick'): {name_list.count('nick')}")
name_list.count('nick'): 1
这个就是来看你的列表里有几个目标对象
5.index()
# list之index()
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"name_list.index('nick'): {name_list.index('nick')}")
name_list.index('nick'): 0
通过输入对象来返回对象的下标
6.clear()
# list之clear()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.clear()
print(f"name_list: {name_list}")
name_list: []
科利尔，顾名思义，清空，clear（你的脑子），你脑袋里就什么都没了，同样的，列表里面全都会被删除掉
7.copy()
# list之copy()
name_list = ['nick', 'jason', 'tank', 'sean']
print(f"name_list.copy(): {name_list.copy()}")
name_list.copy(): ['nick', 'jason', 'tank', 'sean']
扣鼻方法，就是重新开辟出一块内存空间用来放一毛一样的数据，元数据改变，copy的内容不会变。
8.extend()
# list之extend()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list2 = ['nick handsome']
name_list.extend(name_list2)
print(f"name_list: {name_list}")
name_list: ['nick', 'jason', 'tank', 'sean', 'nick handsome']
伊克斯谈得，扩张的意思，你写个东西，他就给你整到列表后头去了吗，
9.reverse()
# list之reverse()
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.reverse()
print(f"name_list: {name_list}")
name_list: ['sean', 'tank', 'jason', 'nick']
这个没办法空耳出来啊。。。。。。ECCQZA0.jpg)
这个的作用就是把列表的全部元素给倒置了。懂吗，你的头和脚对换了，全部翻转。
10.sort()
# list之sort()，使用sort列表的元素必须是同类型的
name_list = ['nick', 'jason', 'tank', 'sean']
name_list.sort()
print(f"name_list: {name_list}")
name_list.sort(reverse=True)
print(f"name_list_reverse: {name_list}")
name_list: ['jason', 'nick', 'sean', 'tank']
name_list_reverse: ['tank', 'sean', 'nick', 'jason']
sort，把你排序了，字符串的话，按首字母来排，一样的话按第二个来，数字就不用讲了。
4.存一个值or多个值：多个值
5.有序or无序：有序
hobby_list = ['read', 'run', 'girl']
print(f'first:{id(hobby_list)}')
hobby_list[2] = ''
print(f'second:{id(hobby_list)}')
first:4522187016
second:4522187016
6.可变or不可变：可变数据类型
二、元组类型内置方法(tuple)
元组说白了就是他娘的一个列表，不可变的列表，你改他东西，他就变id了，变id了代表什么不要我说了，不懂的人找面墙，头拿去咚两下就懂了。
1.用途：和列表一样一样啊，可以存好多妹子
2.定义：用（）来存放了。这个是和列表的区别。
ame_str = ('egon') # ()只是普通包含的意思
name_tuple = ('egon',)
print(f"type(name_str): {type(name_str)}")
print(f"type(name_tuple): {type(name_tuple)}")
type(name_str): <class 'str'>
type(name_tuple): <class 'tuple'>
1.1优先掌握
- 索引取值
- 切片（顾头不顾尾，步长）
- 长度len
- 成员运算in和not in
- 循环
- count
- index
1.索引取值
# tuple之索引取值
name_tuple = ('nick', 'jason', 'tank', 'sean')
# name_tuple[0] = 'nick handsom' # 报错
print(f"name_tuple[0]: {name_tuple[0]}")
name_tuple[0]: nick
没啥好讲的
2.切片（顾头不顾尾，步长）
# tuple之切片
name_tuple = ('nick', 'jason', 'tank', 'sean')
print(f"name_tuple[1:3:2]: {name_tuple[1:3:2]}")
name_tuple[1:3:2]: ('jason',)
切片不就额、也那么回事儿吗？
3.长度
# tuple之长度
name_tuple = ('nick', 'jason', 'tank', 'sean')
print(f"len(name_tuple): {len(name_tuple)}")
len(name_tuple): 4
等一下，这种东西还需要讲吗？
4.成员运算
# tuple之成员运算
name_tuple = ('nick', 'jason', 'tank', 'sean')
print(f"'nick' in name_tuple: {'nick' in name_tuple}")
'nick' in name_tuple: True
这个难道有难度吗？
5.循环
# tuple之循环
name_tuple = ('nick', 'jason', 'tank', 'sean')
for name in name_tuple:
print(name)
nick
jason
tank
sean
6.count()
# tuple之count()
name_tuple = ('nick', 'jason', 'tank', 'sean')
print(f"name_tuple.count('nick'): {name_tuple.count('nick')}")
name_tuple.count('nick'): 1
7.index()
# tuple之index()
name_tuple = ('nick', 'jason', 'tank', 'sean')
print(f"name_tuple.index('nick'): {name_tuple.index('nick')}")
name_tuple.index('nick'): 0
4.存一个值or多个值：多个值
5.有序or无序：有序
name_tuple = ('nick',)
print(f'first:{id(name_tuple)}')
first:4394454152
6.可变or不可变：不可变数据类型
恕我直言，元组在列表面前，就是一个弟弟。过！！！
三、字典类型内置方法（dict）
1.用途：存多个值啊，每一个值都有一个key与之对应。这些key具有描述的功能，比如说身材好的，长得漂亮的。。。。
2.定义：{}内用逗号隔开每一对键值对，每一个元素都是key：value的形式。value可以是任意数据类型，而key通常应该是字符串类型，但是key必须为不可变类型。
1.1优先掌握
- 按key存取值：可存可取
- 长度len
- 成员运算in和not in
- 删除del
- 键keys()、值values()、键值对items()
- 循环
1.按key存取值：可存可取
# dic之按key存取值
dic = {'a': 1, 'b': 2}
print(f"first dic['a']: {dic['a']}")
dic['a'] = 3
print(f"second dic['a']: {dic['a']}")
first dic['a']: 1
second dic['a']: 3
..........这也没什么可以讲得吧
2.长度len
# dic之长度len
dic = {'a': 1, 'b': 2}
print(f"len(dic): {len(dic)}")
len(dic): 2
..........这也没什么可以讲得吧*2
3.成员运算in和not in
# dic之成员运算in和not in
dic = {'a': 1, 'b': 2}
print(f"'a' in dic: {'a' in dic}")
print(f"1 in dic: {1 in dic}")
'a' in dic: True
1 in dic: False
..........这也没什么可以讲得吧*3 哦这个可以讲一下，这里可以判断key也可以判断value是不是in这个字典。
4.删除
# dic之删除del
dic = {'a': 1, 'b': 2}
del dic['a']
print(f"dic.get('a'): {dic.get('a')}")
dic.get('a'): None
以key的形式去删除一个键值对
# dic之删除pop()
dic = {'a': 1, 'b': 2}
dic.pop('a') # 指定元素删除
print(f"dic.pop('b'): {dic.pop('b')}")
print(f"dic.get('a'): {dic.get('a')}")
pop和del的区别就是如果你要从列表中删除一个元素，且不再以任何方式使用它，就使用del语句；如果你要在删除元素后还能继续使用它，就使用方法pop()。
并且pop有返回值，是删除的那个键值对应的value
# dic之删除popitem()
dic = {'a': 1, 'b': 2}
print(f"dic.popitem(): {dic.popitem()}") # popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
dic.popitem(): ('b', 2)
这个就是随机删除一个键值对。我在这上面犟过一些时间，后来被告知是python的底层做了优化，让我们看上去字典像是有序的一样，删除了最后一个，其实是无序的。
5.键keys()、值values()、键值对items()
# dic之键keys()、值values()、键值对items()，python2中取出的是列表（鸡蛋）；python3中取出的是元组（鸡）
dic = {'a': 1, 'b': 2}
print(f"dic.keys(): {dic.keys()}")
print(f"dic.values(): {dic.values()}")
print(f"dic.items(): {dic.items()}")
dic.keys(): dict_keys(['a', 'b'])
dic.values(): dict_values([1, 2])
dic.items(): dict_items([('a', 1), ('b', 2)])
这个不弱。。。这个有用。 之前帮后排同学实现过一个功能，很麻烦，定义了两个变量来存拿出来的东西，当我后来学了这个方法的时候我。。。。.gif)
6.循环
# dic之循环
# dic是无序的，但是python3采用了底层优化算法，所以看起来是有序的，但是python2中的字典是无序
dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
for k, v in dic.items(): # items可以换成keys()、values()
print(k, v)
a 1
b 2
c 3
d 4
这个就那么回事儿。
四、集合类型内置方法（set）
集合就像是列表和字典生下来的孩子，不男不女的，表现形式是怎么样呢？
{1,2,3,4,4,5,6}，这样的，变态吗？ 用着他妈妈的中括号，却用着他爸的存数据方式。
1.用途：用于关系运算的集合体，由于集合内的元素无序且集合元素不可重复，因此集合可以去重，但是去重后的集合会打乱原来元素的顺序。
2.定义：{}内用逗号分隔开多个元素，每个元素必须是不可变类型。
1.1优先掌握
- 长度len
- 成员运算in和not in
- |并集、union
- &交集、intersection
- -差集、difference
- ^对称差集、symmetric_difference
- ==
- 父集：>、>= 、issuperset
- 子集：<、<= 、issubset
1.长度len
# set之长度len
s = {1, 2, 'a'}
print(f"len(s): {len(s)}")
len(s): 3
2.成员运算in和not in
# set之成员运算in和not in
s = {1, 2, 'a'}
print(f"1 in s: {1 in s}")
1 in s: True
3.|并集
# str之|并集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(f"pythoners|linuxers: {pythoners|linuxers}")
print(f"pythoners.union(linuxers): {pythoners.union(linuxers)}")
pythoners|linuxers: {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
pythoners.union(linuxers): {'egon', 'tank', 'kevin', 'jason', 'nick', 'sean'}
4.&交集
# str之&交集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(f"pythoners&linuxers: {pythoners&linuxers}")
print(f"pythoners.intersection(linuxers): {pythoners.intersection(linuxers)}")
pythoners&linuxers: {'nick'}
pythoners.intersection(linuxers): {'nick'}
5.-差集
# str之-差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(f"pythoners-linuxers: {pythoners-linuxers}")
print(f"pythoners.difference(linuxers): {pythoners.difference(linuxers)}")
pythoners-linuxers: {'tank', 'jason', 'sean'}
pythoners.difference(linuxers): {'tank', 'jason', 'sean'}
6.^对称差集
# str之^对称差集
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
print(f"pythoners^linuxers: {pythoners^linuxers}")
print(
f"pythoners.symmetric_difference(linuxers): {pythoners.symmetric_difference(linuxers)}")
pythoners^linuxers: {'egon', 'tank', 'kevin', 'jason', 'sean'}
pythoners.symmetric_difference(linuxers): {'egon', 'tank', 'kevin', 'jason', 'sean'}
7.==
# str之==
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javers = {'nick', 'egon', 'kevin'}
print(f"pythoners==linuxers: {pythoners==linuxers}")
print(f"javers==linuxers: {javers==linuxers}")
pythonerslinuxers: False
javerslinuxers: True
8.父集：>、>=
# str之父集：>、>=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}
print(f"pythoners>linuxers: {pythoners>linuxers}")
print(f"pythoners>=linuxers: {pythoners>=linuxers}")
print(f"pythoners>=javaers: {pythoners>=javaers}")
print(f"pythoners.issuperset(javaers): {pythoners.issuperset(javaers)}")
pythoners>linuxers: False
pythoners>=linuxers: False
pythoners>=javaers: True
pythoners.issuperset(javaers): True
9.子集：<、<=
# str之子集：<、<=
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
javaers = {'jason', 'nick'}
print(f"pythoners<linuxers: {pythoners<linuxers}")
print(f"pythoners<=linuxers: {pythoners<=linuxers}")
print(f"javaers.issubset(javaers): {javaers.issubset(javaers)}")
pythoners<linuxers: False
pythoners<=linuxers: False
javaers.issubset(javaers): True
讲真，这些方法都很带劲啊，当你要比较两个列表内的元素是否都相同的时候，就不需要在写两个循环了呀，直接强制转换成集合类型，然后用集合类内置方法来比较一下啊就完事儿了啊，其他的方法也是适合各种时候的需求的。
对不起，刚才骂你是变态。
1.2需要掌握
- add
- remove
- difference_update
- discard
- isdisjoint
1.add()
# set之add()
s = {1, 2, 'a'}
s.add(3)
print(s)
{1, 2, 3, 'a'}
2.remove()
# set之remove()
s = {1, 2, 'a'}
s.remove(1)
print(s)
{2, 'a'}
3.difference_update()
# str之difference_update()
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.difference_update(linuxers)
print(f"pythoners.difference_update(linuxers): {pythoners}")
pythoners.difference_update(linuxers): {'tank', 'jason', 'sean'}
4.discard()
# set之discard()
s = {1, 2, 'a'}
# s.remove(3) # 报错
s.discard(3)
print(s)
{1, 2, 'a'}
5.isdisjoint()
# set之isdisjoint()，集合没有共同的部分返回True，否则返回False
pythoners = {'jason', 'nick', 'tank', 'sean'}
linuxers = {'nick', 'egon', 'kevin'}
pythoners.isdisjoint(linuxers)
print(f"pythoners.isdisjoint(linuxers): {pythoners.isdisjoint(linuxers)}")
pythoners.isdisjoint(linuxers): False
以上的方法就只用做了解一下，说实话集合用到的机会不多，比较冷。
