列表的内置方法
统计当前列表内指定元素的个数
l1 = ['jinyi','wanglu','qiaobi','love','jinyi']
print(l1.count('jinyi'))
# 2
index
获取当前指定元素的索引值，还可以指定查找范围
l1 = ['jinyi','wanglu','qiaobi','love','jinyi']
print(l1.index('jinyi',1,5))
# 4
sort
排序，在原列表上进行排序操作
s1 = [2, 1, 4, 6, 8, 3, 5, 6]
s1.sort()
print(s1) # 正序：[1, 2, 3, 4, 5, 6, 6, 8]
s1.sort(reverse=True)
print(s1) #倒序：[8, 6, 6, 5, 4, 3, 2, 1]
s2 = sorted(s1,)
print(s2) ## python的内置函数，在排序时生成了一个新列表
clear
清空列表数据
s1 = [2, 1, 4, 6, 8, 3, 5, 6]
s1.clear()
print(s1)
队列堆栈
# 队列：先进先出
# l1.append(1)
# l1.append(2)
# l1.append(3)
# print(l1)
# l1.pop(0)
# print(l1)
# l1.pop(0)
# l1.pop(0)
# print(l1)
# 堆栈：先进后出
# l1.append(1)
# l1.append(2)
# l1.append(3)
# print(l1)
# l1.pop()
# print(l1)
# l1.pop()
# print(l1)
# l1.pop()
# print(l1)
元组(tuple)
用途：储存多个不同类型的值（不能存可变类型）
定义方式：用小括号储存数据，数据之间用逗号分隔，（值不能被改变）
定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号
在元组中如果不加，就是字符串
t1 = ('a','b','c','a') # t1 = tuple(('a','b'))
print(t1)
索引取值（正取，反取都可以）索引切片
t1 = ('a','b','c','a')
print(t1[2]) # 正取'c'
print(t1[-2]) # 反取'c'
print(t1[1:4]) #切片('b', 'c', 'a')
in ot incountindex
元组可以索引，所有是有序的，是不可变类型，能存多个值
字典
通过大括号来储存数据，通过key:value来定义键值对数据，每个键值对中间用逗号分隔
key:一定是一个不可变类型
value:可以是任意类型
字典的三种定义方式
z1 = {'name':'jinyi','airen':'wanglu','age':18}
z2 = dict({'name':'jinyi','airen':'wanglu','age':18})
zip : 了解即可
l1 = ['name',"age"]
l2 = ['egon',18]
z1 = zip(l1,l2)
print(dict(z1))
按照key:value映射关系取值（可存可取）
成员运算in , not in #默认判断key
len() # 获取当前字典中键值对的个数
# d1 = {'name':'egon', 'age': 73}
# print(d1['name'])
# print(d1['age'])
# d1['name'] = 'tank'
# d1['gender'] = 'male'
# print(d1)
# print('egon' in d1)
# 内置方法：
# get(******) : 获取指定key的值，如果值不存在·，默认返回None,可以通过第二个参数修改默认返回的内容
# print(d1['gender'])
# print(d1.get('gender'))
# print(d1.get('gender','male'))
# keys、values、items ******
# print(d1.keys()) # 返回所有的key
# print(d1.values()) # 返回所有的值
# print(d1.items()) # 返回所有的键值对，返回值是列表套元组，每一个键值对都是存在元组
# for key in d1.keys():
# print(key)
# for value in d1.values():
# print(value)
# for key,value in d1.items():
# print(key,value)
# key,value = ("name",'age')
# pop:删除 ： 指定key进行删除，有返回值，返回为对应的value
# a = d1.pop('name')
# print(d1)
# print(a)
# popitem() ,随机弹出一个键值对，有返回值，返回只是一个元组
# d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
#
# d1.popitem()
# print(d1)
# update : 用新字典替换旧字典
# d1.update({"b":'2'})
# print(d1)
# d1.update({'name':'tank'})
# print(d1)
# fromkeys : 生产一个新字典， 第一个参数（列表），它会以第一个参数中各个元素为key，以第二个参数为值，组成一个新字典
# print(dict.fromkeys([1,2,3],['ke','k1']))
# setdefault :key不存在新增键值对，有返回值，返回新增value，key存在返回对应的value
# d1 = {'name':'egon', 'age': 73,'gender':'male','a':"1"}
#
# print(d1.setdefault('name',1))
# print(d1)
# =========================类型总结==========================
# 有序or无序 ： 无序
# 可变or不可变 ：可变类型
# 存一个值or存多个值 ： 存多个值
合集
# ========================集合基本方法===========================
# 用途: 去重、关系运算
# 定义方式: 通过大括号存储数据，每个元素通过逗号分隔
# 定义空集合，必须使用set()来定义
# l1 = []
# s1 = ""
# d1 = {}
# ss1 = set()
# 常用方法:
"""
合集：|
交集：&
差集：-
对称差集：^
"""
"""
1、集合中不可能出现两个相同的元素
"""
python_student = {'egon', 'jason', 'tank', 'owen', 'egon'}
linux_student = {'frank', 'alex', 'egon'}
go_student = {'egon'}
print(python_student)
# print(python_student | linux_student)
# print(python_student & linux_student)
# print(python_student - linux_student)
# print(linux_student - python_student)
# print(python_student ^ linux_student)
# print(python_student > go_student)
# print(python_student < linux_student)
# l1 = [1, 2, 3, 1, 2, 9, 1, 5, 6, 7]
# print(l1)
#
# s1 = set(l1)
# print(s1)
# print(type(s1))
# l2 = list(s1)
# print(l2)
# print(type(l2))
for i in python_student:
print(i)
# =========================类型总结==========================
# 有序or无序 : 无序
# 可变or不可变 : 不可变
# 存一个值or存多个值 ： 存多个值
全部总结
列表及内置方法
增：
append # 在列表尾部追加单个元素
insert # 指定索引在列表中插入单个元素
extend # 一次性插入多个值
for + append
删：
del 万能删
remove
pop
改：
pass
查：
pass
内置方法：
1、len()
2、sort(reverse=True) #
sorted
3、reverse # 反转
4、count # 统计当前指定元素，在列表中出现的次数
5、index # 获取指定值的索引
7、clear # 清空
元组及内置方法
定义方式：
通过小括号存储数据，数据之间通过逗号分隔
在定义容器类型时候，一定要在定义的元素后面加一个逗号
s1 = (1)
元组与列表的区别：
1、存储数据，一个[],一个()
2、元组不可变，列表可变
内置：
1、count
2、index
字典及内置方法：
定义方式：
通过大括号存储数据，通过key:value的映射关系生成键值对，
键值对之间要通过逗号分隔
三种定义方式：
d1 = {'name':'sean','age':18}
d2 = dict(name='sean',age=18)
d3 = dict(zip(['name','age'],['sean',18]))
增：
d1['new_key'] = 'new_value'
d1.update({'name':'tank'}) # 用新字典去更新旧字典
d1.setdefault('name','egon')
# 如果传入的值已存在于字典，返回原来的value
# 如果传入的值不存在于字典，新增一条数据，返回更新之后的value
删：
del
d1.pop() # pop弹出值，传入对应的key，只返回值，不返回key
d1.popitem() # 随机弹出整个键值对，返回值一个元组，元组中存储的就是key:value
改：
pass
查：
d1['key'] # 不存在就报错
d1.get('gender')
内置方法：
keys() # 就当它返回的是一个列表 返回所有的键
values() # 返回所有的值
items() # 返回所有的键值对
fromkeys()
集合及内置方法:
定义方式：
通过大括号存储数据，数据之间通过逗号分隔
定义空集合，必须使用set()
作用：
1、关系运算
2、去重
三个特性：
1、集合里面的值是不可重复的
2、集合内存储的元素必须是不可变的
3、集合内的元素是无序的
集合的内置方法：
交集
并集
差集
对称差集
判断父集、子集
add()
remove()
discard()
总结:
可变：列表，字典，集合
不可变：数字类型，字符串、元组