列表、字典、元组、集合的内置方法

今天一整天都没有拉屎，我很难受，一点状态都没有

还好学习没有阻塞。

今天的憨憨们有没有给自己打气呀，上图

每天都要相信自己，一定要有相信的东西。

今日洗脑金句： 心若不狠，战意不稳，天天狂刷题，心停手不停。

一、列表类型内置方法

1.用途：多个东西，什么东西呢，多个女朋友啊，多个男朋友啊，多个乱七八糟的。

2.定义：[]内可以有多个任意类型的值，用逗号分隔每个元素

my_girl_friend = ['韩红', '凤姐', '钟源']
print(f"my_girl_friend: {my_girl_friend}")

my_girl_friend: ['韩红', '凤姐', '钟源']

就这么回事，可以通过索引来取值，之前都讲过很多次了，你在不懂我就生气了。

1.1优先掌握

1. 按索引取值（正向取值+反向取值），即可存也可以取
2. 切片
3. 长度len
4. 成员运算in和not in
5. 追加append
6. 删除del
7. 循环

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']

这个就是列表独有的内置方法了，这个方法有点好用哦，他是什么意思呢，就是你在这个方法体内写入一个参数，就会被追加到调用这个方法的对象的屁股上去，对，最后，屁股的位置

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需要掌握

1. insert
2. pop
3. remove
4. count
5. index
6. clear
7. copy
8. extend
9. reverse
10. 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']

这个没办法空耳出来啊。。。。。。

这个的作用就是把列表的全部元素给倒置了。懂吗，你的头和脚对换了，全部翻转。

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优先掌握

1. 索引取值
2. 切片（顾头不顾尾，步长）
3. 长度len
4. 成员运算in和not in
5. 循环
6. count
7. 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优先掌握

1. 按key存取值：可存可取
2. 长度len
3. 成员运算in和not in
4. 删除del
5. 键keys()、值values()、键值对items()
6. 循环

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)])

这个不弱。。。这个有用。 之前帮后排同学实现过一个功能，很麻烦，定义了两个变量来存拿出来的东西，当我后来学了这个方法的时候我。。。。

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优先掌握

1. 长度len
2. 成员运算in和not in
3. |并集、union
4. &交集、intersection
5. -差集、difference
6. ^对称差集、symmetric_difference
7. ==
8. 父集：>、>= 、issuperset
9. 子集：<、<= 、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需要掌握

1. add
2. remove
3. difference_update
4. discard
5. 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

以上的方法就只用做了解一下，说实话集合用到的机会不多，比较冷。