列表
# l1 = ['sean', 'egon', 'tank', 'sean']
# count:统计当前列表内指定元素的个数
s1 = ["asd", "sde", "weq", 1223, 1223]
print(s1.count(1223))
>>2
# index : 获取当前指定元素的索引值，还可以指定指定查找范围
s1 = ["asd", "sde", "weq", 1223, 1223]
print(s1.index(1223, 1, 4))
>>3
# sort:排序，在原列表上进行排序操作
s2 = [2, 10, 5, 6, 8]
s2.sort()
>>>[2, 5, 6, 8, 10]
s1 = ["asd", "sde", "weq"]
s1.sort()
print(s1)
>>>['asd', 'sde', 'weq']
reverse 是用来把值反转
a1 = [1, 2, 'ads']
a1.reverse()
print(a1)
>>>>>>
['ads', 2, 1]
sorted python的内置函数，在排序时生成了一个新列表，原数据不变
s2 = [2, 10, 5, 6, 8]
l1 = sorted(s2) #python 的内置函数
print(l1)
# clear() 清空列表数据
s2 = [2, 10, 5, 6, 8]
s2.clear()
print(s2)
>>[]
队列：先进先出
s1 = []
s1.append(1)#先安排进去
s1.append(2)
s1.append(3)
print(s1)
s1.pop(0)#先进的安排出来
print(s1)
s1.pop(0)
s1.pop(0)
print(s1)
对栈 ：先进的后出
s1 = []
s1.append(1)#先进的 依次
s1.append(2)
s1.append(3)
print(s1)
s1.pop()#后进的后出
print(s1)
s1.pop()
s1.pop()
print(s1)
元组
# ========================元组基本方法===========================
# 用途:存储多个不同类型的值（可以存可变类型和不可变类型）
# 定义方式:用过小括号存储数据，数据与数据之间通过逗号分隔,(值不能被改变)
# 定义容器类型的时候，如果里面只有一个值，在值的后面加上一个逗号*****
# 在元组中如果不加，就是字符串
#元组是不可变的类型
与列表的区别是：
元组的元素不能修改，元组相当于不可变的列表，用于记录多个固定不修改的值，单独用于取
t1 = ("a", 'b', 'c', 'd') # t1 = tuple(('a', 'b', 'c', 'd'))
# print(type(t1))
print(t1[2])#索引取值
print(t1[1:3])#索引切片
print('a' in t1)#成员判断
print(len(t1))#长度
for i in t1:
print(i)
>>>
a
b
c
d
count 数出一个值得个数
a1 = (1, 2, 3, 3, 'sda')
print(a1.count(3))
>>>>>>
2
index 指定值得索引位置
a1 = (1, 2, 3, 3, 'sda')
print(a1.index(2))
>>>>>
1
# =========================类型总结==========================
# # 有序or无序 : 有索引，有序
# # 可变or不可变: 不可变
# # 存一个值or存多个值：存多个值
字典
# ========================字典(dict)基本方法===========================
# 用途:
# 定义方式:通过大括号来存储数据，通过key:value来定义键值对数据，每个键值对中间通过逗号分隔
# key:一定是一个不可变类型
# value：可以是任意类型
# d1 = {(1,2):[1,2]}
"""
字典的三种定义方式·：
"""
# 1、*****
# d1 = {'name':'egon','age':84}
# 2、*****
# d2 = dict({'name':'egon'})
# 3、zip : 了解即可
# l1 = ['name',"age"]
# l2 = ['egon',18]
# z1 = zip(l1,l2)
# print(dict(z1))
下面也是字典的定义方式之一
d2 = dict(name='sean',age=18)
1、优先掌握的
1、按照key:value映射关系取值（可存可取）
2、成员运算in，not in # 默认判断key
3、len() # 获取当前字典中键值对的个数
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1['a'])
print(s1['d'])
s1['a'] = 'tank'
print(s1)
s1['f'] = 'morning'
print(s1)
>>>>>
abs
123
{'a': 'tank', 'b': 'wedding', 'd': 123}
{'a': 'tank', 'b': 'wedding', 'd': 123, 'f': 'morning'}
# 内置方法：
# get(******) : 获取指定key的值，如果值不存在·，默认返回None,可以通过第二个参数修改默认返回的内容
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1['b'])
print(s1.get('b'))
print(s1.get('h'))
print(s1.get('h', 'konghong'))
>>>>>
wedding
wedding
None
konghong
# keys、values、items ******
# print(d1.keys()) # 返回所有的key
# print(d1.values()) # 返回所有的值
# print(d1.items()) # 返回所有的键值对，返回值是列表套元组，每一个键值对都是存在元组
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1.keys())
print(s1.values())
print(s1.items())
>>>>>>
dict_keys(['a', 'b', 'd'])
dict_values(['abs', 'wedding', 123])
dict_items([('a', 'abs'), ('b', 'wedding'), ('d', 123)])
for 循环
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
for key in s1.keys():
print(key)
for value in s1.values():
print(value)
for item in s1.items():
print(item)
＞＞＞＞＞
a
b
d
abs
wedding
123
('a', 'abs')
('b', 'wedding')
('d', 123)
# pop:弹出 ： 指定key进行弹出，有返回值，返回为对应的value
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
a = s1.pop('b')
print(a)
print(s1)
＞＞＞＞
wedding
{'a': 'abs', 'd': 123}
# popitem() ,随机弹出一个键值对，有返回值，返回只是一个元组
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
s1.popitem()
print(s1)
＞＞＞＞
{'a': 'abs', 'b': 'wedding'}
# update : 用新字典替换旧字典 有新的就添加上，有旧的就是去替换。
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
s1.update({'d': "ending "})
print(s1)
＞＞＞＞
{'a': 'abs', 'b': 'wedding', 'd': 'ending '}
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
s1.update({'a': "ending "})
print(s1)
＞＞＞＞＞
{'a': 'ending ', 'b': 'wedding', 'd': 123}
update可以更新一个字典
l1 = {}
l1.update({'dd':123})
print(l1)
>>>>>>>>>>>
{'dd': 123}
# fromkeys : 生产一个新字典， 第一个参数（列表），它会以第一个参数中各个元素为key，以第二个参数为值，组成一个新字典
print(dict.fromkeys([1, 2, 3], ['k', 'h']))
＞＞＞
{1: ['k', 'h'], 2: ['k', 'h'], 3: ['k', 'h']}
# setdefault :key不存在新增键值对，有返回值，返回新增value 如果key存在键值对，存在返回对应的value
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1.setdefault('a'))
>>>>>>
abs
s1 = {"a": 'abs', 'b': 'wedding', 'd': 123}
print(s1.setdefault('j', 908))
＞＞＞
908
# =========================类型总结==========================
# 有序or无序 ： 无序
# 可变or不可变 ：可变类型
# 存一个值or存多个值 ： 存多个值
集合
# ========================集合基本方法===========================
# 用途: 去重、关系运算
# 定义方式: 通过大括号存储数据，每个元素通过逗号分隔
# 定义空集合，必须使用set()来定义
3个特性：
1.
# l1 = []
# s1 = ""
# d1 = {}
# ss1 = set()
# 常用方法:
合集：|
交集：&
差集：-
对称差集：^
1、集合中不可能出现两个相同的元素
a = {'asa', 'dfs', 'fds', 'aaa'}
b = {'dws', 'caz', 'aqw', 'aaa'}
c = {'dws', 'caz'}
print(a | b)
print(a & b)
print(a - b)
print(a ^ b)
>>>>
{'dws', 'aqw', 'fds', 'caz', 'asa', 'dfs', 'aaa'}
{'aaa'}
{'dfs', 'fds', 'asa'}
{'dws', 'aqw', 'fds', 'caz', 'asa', 'dfs'}
父集 子集
a = {'asa', 'dfs', 'fds', 'aaa'}
b = {'dws', 'caz', 'aqw', 'aaa'}
c = {'dws', 'caz'}
print(b >= c)
print(c <= b)
>>>>
True
True
去重
只针对于不可变类型，集合本身是无序的，去重之后，无法保留原来的顺序
s1 = [1, 2, 3, 4, 2, 5, 6, 5]
print(s1)
s2 = set(s1)
print(s2)
print(type(s2))
s3 = list(s2)
print(s3)
print(type(s3))
>>>>
[1, 2, 3, 4, 2, 5, 6, 5]
{1, 2, 3, 4, 5, 6}
<class 'set'>
[1, 2, 3, 4, 5, 6]
<class 'list'>
总结
存一个:整型、浮点型、字符串
存多个值：列表、元组、字典、集合
可变or不可变：
可变：；列表，字典、集合
不可变：整型、浮点型、字符串、元组、
有序or无序：
有序：字符串、列表、元组
无序：字典、集合
占用空间：
字典
列表
元组
集合
字符串
数字类型
"""