列表，元组，字典，集合的常用内置方法

一、列表及其常用内置方法

l = [1, 1, 1, 1, 1, 2, 3, 4, 5, 6, 7]
print(l.count(1))  # 计数 记录一个元素在列表中出现的次数

l.clear()
print(l)  # 清除列表中的所有元素，无返回值

l = [1, 2, 3, 4, 5, 6, 7]
print(id(l))
l.reverse()  # 将列表中的元素翻转，直接修改列表
print(l)
print(id(l))

l = [12, 2, 5, 1, 89, 1002, 684]
l.sort()
print(l)
# 将列表中的数字排序，默认从小到大排序
l.sort(reverse=True)
print(l)
# 通过指定参数来修改默认的排序规则（降序）

# 模拟队列 先进先出
l1 = []
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 先出
print(l1.pop(0))
print(l1.pop(0))
print(l1.pop(0))

# 模拟堆栈 先进后出
l1 = []
# 先进
l1.append('first')
l1.append('second')
l1.append('third')
# 后出
print(l1.pop())
print(l1.pop())
print(l1.pop())

　　

二、元组及其常用内置方法

# 作用：能够存储多个元素，元素与元素之间逗号隔开  元素可以是任意类型,元组不能被修改

# 定义：与列表类型比，只不过[]换成()
age = (11, 22, 33, 44, 55)  # 本质age=tuple((11,22,33,44,55))

# 优先掌握的操作：

# 1、按索引取值(正向取+反向取)，只能取
t = (1, 2, 3, 'a', 'b', [1, 2, 3])
print(t[0])
t[1] = 'hahah'  # 报错
t[-1][0] = 'hahah'  # 不报错
# 元组是不可变类型，但是如果元组内部有可变类型数据如list、dict、set等，这些元素内部的值是可以改变的

del t[0]  # 报错

# 2、切片(顾头不顾尾，步长)
print(t[::2])

# 3、长度
print(len(t))

# 4、成员运算in和not in
print('a' in t)

# 5、循环
for i in t:
    print(i)

　　

三、字典及其内置方法

# 作用：能存存储多组 key:value键值对  key是对value的描述  key通常情况下都是字符串
# 其实这个key只能是不可变类型,value可以是任意数据类型
d1 = {1: '1', 0: '0', 1.11: '1.11', (1, 2): '到底能不能呢?'}

# 定义：
d = {'name': 'jason', 'password': 123}  # d = dict( {'name':'jason','password':123})

d2 = {'name': 'jason', 'name': 'tank', 'name': 'nick', 'password': 123}
print(d2)  # 输出{'name': 'nick', 'password': 123}
# 强调:字典的key是不能重复的 要唯一标识一条数据
# 如果重复了 只会按照最后一组重复的键值对存储

# 优先掌握的操作：
# 1、按key存取值：可存可取
d3 = {'name': 'jason', 'password': '123'}
print(d3['name'])
d3['name'] = 'egon'
print(d3)  # {'name': 'egon', 'password': '123'}

# d3['age'] = 18  # 赋值语句当key不存在的情况下，会自动新增一个键值对(******)
print(d3, id(d3))

# 2、长度len
# 统计键值对的个数

# 3、成员运算in和not in   对于字典来说只能判断key值
d3 = {'name': 'jason', 'password': '123'}
print('123' in d3)  # False
print('name' in d3)  # True

# 4、删除
d3 = {'name': 'jason', 'password': '123'}

del d3['name']
print(d3)  # {'password': '123'}

res = d3.pop('name')
print(res)  # jason  弹出仅仅是value

res = d3.pop('age')  # 当键不存在的时候直接报错

d3.clear()  # 清空元素
print(d3)

# 定义字典的三种方式
# 掌握
d1 = {'name': 'jason', 'password': 123}
d2 = dict(name='jason', password=123, age=18)  # (******)

# 了解即可
l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]
d = {}
# for i in l:  # ['name','jason'],['age',18]...
for k, v in l:  # ['name','jason'],['age',18]... 这里相当于k，v=['name','jason'] 解压赋值操作
    # d[i[0]] = i[1]
    d[k] = v
print(d)  # {'name': 'jason', 'age': 18, 'hobby': 'read'}

l = [
    ['name','jason'],
    ['age',18],
    ['hobby','read']
]
d3 = dict(l)
print(d3)  # {'name': 'jason', 'age': 18, 'hobby': 'read'}

# 5、键keys()，值values()，键值对items()
d1 = {'name': 'jason', 'password': 123}
print(d1.keys())  # dict_keys(['name', 'password'])  老母猪
# for k in d1.keys():
#     print(k)
print(d1.values())  # dict_values(['jason', 123])  老母猪  现在就把它当成一个列表来看即可

print(d1.items())  # dict_items([('name', 'jason'), ('password', 123)])
# 就把它看成是列表套元组，元组的第一个元素是字典的key 第二个元素是字典的value

# get()根据key获取value（*******************************）
d1 = {'name': 'jason', 'pwd': 123}
print(d1['name'])
print(d1['age'])  # 报错 不存在该key值
print(d1.get('name', '你给我的name在字典的key中'))  # 即使key不存在也不会报错
res = d1.get('age')  # 当字典的key不存在的情况 不报错 返回None

res1 = d1.get('xxx', '你给我的age在字典的key中')  # 当字典的key不存在的情况 不报错 返回None
print(res1)  # 输出  你给我的age在字典的key中
# get可以传第二个参数。当你的key不存在的情况下，返回第二个你写好的参数信息

print(d1.get('xxx', 'asdsad'))  # 输出 asdsad
# 第二个参数不写的话 当key不存在的情况下返回None，写了就返回写的内容

# dict.fromkeys()  # 快速的创建一个字典
l1 = ['name', 'password', 'age', 'hobby']
print(dict.fromkeys(l1, 123))
# {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}

# dict.popitem()
d1 = {'name': 123, 'password': 123, 'age': 123, 'hobby': 123}
print(d1.popitem())  # 尾部以元组的形式弹出键值对 ('hobby', 123)

 dict.setdefault()
d1 = {'name': 'jason', 'pwd': 123}
res1 = d1.setdefault('name', 'xxoo')  # 当键存在的情况下 不修改值 并且将原先key对应值返回给你
print(d1, res1)
res2 = d1.setdefault('age', 18)  # 当键不存在的情况下 新增一个键值对 并且将新增的键值对的值返回给你
print(d1, res2)
# {'name': 'jason', 'pwd': 123} jason
# {'name': 'jason', 'pwd': 123, 'age': 18} 18

# dict.update()
d1 = {'name': 'jason', 'pwd': 123}
d2 = {"age": 18}
d1.update(d2)
print(d1)  # {'name': 'jason', 'pwd': 123, 'age': 18}

# 只添加一个元素，用赋值同样可以实现
d1['age'] = 18
print(d1)  # {'name': 'jason', 'pwd': 123, 'age': 18}

# 另一种方式
d1.update(age=666, message='hahah')
print(d1)

# 6、循环
d1 = {'name': 'jason', 'password': 123}
for i in d1:
    print(i)

　　

四、集合及其内置方法

# 定义：
# 集合：可以包含多个元素，用逗号分割
s = {1, 2, 3, 4, 5, 6}  # <class 'set'>  # s = set()
print(type(s))

s1 = set()
print(type(s1))  # 注意在定义空集合的只能用关键字set

x = {}  # <class 'dict'>  如果你仅仅只写了一个大括号 那么python默认将它当做字典类型
print(type(x))

# 集合的元素遵循三个原则：
# 1：每个元素必须是不可变类型
# 可变:不可hash
# 不可变:可hash
s = {1, 2, 3, 4, 5, 6, 'a', (1, 2), [1, 2]}  # 报错
s = {1, 2, 3, 4, 5, 6, 'a', (1, 2), {"name": 'jason'}}  # 报错

# 2: 没有重复的元素
s = {1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 5}
print(s)  # 自动将重复的元素去除  {1, 2, 3, 4, 5}

# 3：无序
s = {1, 2, 3, 4, 5, 6}
print(s[1])  # 报错，无法通过索引取值

# 注意集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

# 优先掌握的操作：
# 1、长度len
# 2、成员运算in和not in
# 3、|合集
# 4、&交集
# 5、-差集
# 6、^对称差集
# 7、==
# 8、父集：>,>=
# 9、子集：<,<=

# 1、长度len
s = {1, 2, 3, 4}
print(len(s))

# 2、成员运算in和not in
s = {1, 2, 3, 4}
print(1 in s)  # True

pythons = {'jason', 'nick', 'tank', 'egon', 'kevin', 'owen', 'alex'}
linux = {'frank', 'jerry', 'tank', 'egon', 'alex'}
# 既报名python也报名linux的学生姓名
print(pythons & linux)  # 交集

# 只报名python的学生姓名
print(pythons - linux)
# 只报名linux的学生姓名
print(linux - pythons)

# 没有同时报名两门课程的学生姓名
print(pythons ^ linux)  # 对称差集

# 取出所有报了名的学生姓名
print(pythons | linux)

s = {1, 2, 3, 4, 5}
print(s.add(666))
print(s.add((1, 2, 3, 4)))  # 将容器类型也当成一个元素传入

print(s.remove(1))
print(s)  # 移除的元素不在集合中时会报错
print(s.discard(888888888))
print(s)  # 移除的元素不在集合中时不会报错