今天仍然没复习，因为人家留作业了但我没有*-*，今天仍然学的内置方法，昨天学的各种数据的，今天学的列表，元组，字典，集合等类型的内置方法，学了好多好多快捷语言，没法概述，但又有一点，明天总复习完一定要先总结一下哪些是直接更改可以直接输出，哪些是操作，需要操作完在输出，直接输出返回none。哎对，今天没学完，剩个总结和总复习，晚上有课明天再听（上课带耳机真的很没安全感*-*),下班！
目录1 列表的内置方法
- 作用：存多个元素，兴趣爱好，私生子的名字
- 定义方式： []内用逗号隔开任意类型的元素，name_list = ['xiaoxiao','xiaoda','xiaoxue','xiaochen']
- s.list( )
- 方法： 优先掌握，需要掌握，了解
- 存储一个值or多个值：多个值
- 有序or无序：有序
- 有序：有索引
- 无序：无索引
- 可变不可变：可变
- 可变：值变id变
- 不可变：值变id不变
1.1 优先掌握
name_list = ['jinchanchan','yuanshen','lol','cf','wangzherongyao','hepingjingying','and more']
# 按索引取值 可存可取
print(name_list[1])
print(name_list[-1])
# 切片 按段来索引
print(name_list[0:3])
print(name_list[-3:])
# 长度 len（）
print(len(name_list))
# 成员运算 in or not in
print('jinchanchan' in name_list)
print('pubg' not in name_list)
# 追加 append ,注意append是在列表后新增一个值，直接输出不会返回值
print(name_list.append('pubg'))
name_list.append('pubg')
print(name_list)
# 删除 del下面的是错误的，del语法不是这么用的 准确 删除cf del name_list[3]
#print(name_list.del('cf'))
#print(name_list)
del name_list[3]
print(name_list)
# 循环 for i in name_list
for i in name_list:
print(i)
1.2 需要掌握
beertype_list = ['yongchuangtianya','chunsheng','baiwei','wusu','haerbin','jinxing']
# insert 在索引前面加个值
beertype_list.insert(0,'xuehua')
print(beertype_list)
beertype_list.insert(-1,'xili') #由于是在前面，因此-1的前面是-2
print(beertype_list)
# pop 默认删除最后一个值，可以加index，删除指定
beertype_list.pop()
print(beertype_list)
beertype_list.pop(4)
print(beertype_list)
# remove 指定对象删除，如果对对象不存在则报错
beertype_list.remove('haerbin')
print(beertype_list)
# count 计数 计算列表找某个元素的数量
beertype_list.insert(2,'baiwei')
print(beertype_list.count('baiwei'))
# index 获取指定元素的索引，但只会获取第一次
print(beertype_list.index('baiwei'))
# clear 清空列表 同上面的删除，是一个操作，无返回值，直接输出返回none
#beertype_list.clear()
print(beertype_list)
# copy 复制，复制一个完全一样的新列表
copy_list = beertype_list.copy()
print(beertype_list)
print(copy_list)
# extend 扩展。把后面列表的元素加入到原列表中,#同上面的del，clear一样，是一个操作过程无返回值，直接输出返会none
beertype_list.extend(copy_list)
print(beertype_list)
# reverse 反转，把列表内容反转,同上述的del，clear，extend，是一个直接对原列表的操作无返回值，直接输出返回none
beertype_list.reverse()
print(beertype_list)
# sort 把字母从小到大排序,同上述的del，clear，extend，reverse是一个直接对原列表的操作无返回值，直接输出返回none
beertype_list.sort()
print(beertype_list)
2 元组类型的内置方法
- 作用：类似于列表，只不过元组只能取不能更改
- 定义方式：（）内用逗号隔开任意类型的元素
- hobby_tuple = ('chang','tiao','rap',1)
- hobby_tuple = tuple（ ('chang','tiao','rap',1)）
- 方法： 优先掌握，需要掌握，了解，
- 存储一个值or多个值：多个值
- 有序or无序：有序
- 有序：有索引
- 无序：无索引
- 可变不可变：不存在可变不可变
- 可变：值变id变
- 不可变：值变id不变
以后只用列表，从来没看过元组
songs_tuple = ('xiaochou','dahai','hongsegaogenxie','dahai','musehuixiang','dahai')
# 索引取值 可以直接找出某个元素的索引值（位置）
print(songs_tuple[-1])
# 切片
print(songs_tuple[0:3])
# 长度len
print(len(songs_tuple))
#成员运算 in | not in
print('dahai' in songs_tuple)
print('dear john' not in songs_tuple)
# 循环
for i in songs_tuple:
print(i)
# count 获取指定元素的个数
print(songs_tuple.count('dahai'))
# index 获取指定元素的索引
print(songs_tuple.index('hongsegaogenxie'))
3 字典类型的内置方法
- 作用：当列表存很多值会显得很乱，因此有字段
- 定义方式： {}内以逗号分隔键值对，key：value的值，key一般是字符串，一边对值具有描述意义，value可以是任意数据类型
- 方法： 优先掌握，需要掌握，了解，
- 存储一个值or多个值：多个值
- 有序or无序：无序
- 有序：有索引
- 无序：无索引
- 可变不可变：不可变
- 可变：值变id变
- 不可变：值变id不变
ch_dict = {'name':'sunchenghao',
'gender':'male',
'height':190,
'weight':180,
'hobby_list':['chi','he','piao','du']}
# 按key存取值
print(ch_dict['gender'])
print(ch_dict['hobby_list'])
# 长度len
print(len(ch_dict))
print(len(ch_dict['name']))
# 成员运算 in | not in 这个成员运算用的是key值
print('name' in ch_dict)
print('sunchenghao' in ch_dict)
print('male' not in ch_dict)
# 删除 del 删除同样是用的key值
del ch_dict['gender']
print(ch_dict)
# 键keys（），值values（），键值对items（） ********，取出的所有值都是列表
print(ch_dict.keys())
print(ch_dict.values())
print(ch_dict.items())
# for循环 for i in dict 可以看出，i in ch_dict 等于 i in ch_dict.keys()
for i in ch_dict:
print(i)
for i in ch_dict.keys():
print(i)
for i in ch_dict.values():
print(i)
for i in ch_dict.items():
print(i)
for k, v in ch_dict.items():
print(k, v)
# get（key，51） 得到值 ，跟直接用键取值相比好在哪？ 如果键不存在，返回none，不会报错，如果键不存在，可以设定默认值
print(ch_dict['name'])
print(ch_dict.get('name',100))
# print(ch_dict['gender']) 报错了
print(ch_dict.get('gender',100))
# update 有则更新 没有则添
ch_dict.update({'gender':'male','name':'sch'})
print(ch_dict)
# fromkeys 默认吧给定列表里的元素取出来当中key，然后使用一个默认的value新建一个value,
# 这个value不管是啥，所有的键值都对应这个value，
dic_new = dict.fromkeys([1,2,3,4,5,6],[1,2,3,4,5,6])
print(dic_new)
# setdefault 增加一个键值对进去，但如果已有该key，则原key的值不变
ch_dict.setdefault('name','sunchenghao')
print(ch_dict)
ch_dict.setdefault('123',456)
print(ch_dict)
4 集合类型内置方法
- 作用：存储多个值
- 定义方式：{ }内以逗号隔开多个元素，这个元素必须是不可变类型（不是任意类型）,不可哈希就是可变，哈希就是不可变
- s =
- s = set() 空集合
- 方法：见下面代码
- 存储一个值or多个值：多个值
- 有序or无序：无序
- 有序：有索引
- 无序：无索引
- 可变不可变：不可变
- 可变：值变id变
- 不可变：值变id不变
s = ('dawang','dasun','daliang','daxue','dawu','dachen','dasun','daxue')
print(s)
# 去重 去除重复 驱虫的同时，会打乱列表原来的顺序
print(80*'-')
s_set = set(s)
s_list = list(s_set)
print(s_list)
print(s_set)
# 长度 len
print(80*'-')
print(len(s_set))
# 成员运算 in | not in
print(80*'-')
print('daxue' in s_set)
print('xiaozhou' not in s_set)
# 并集 | union
print(80*'-')
python = {'xiaowang','xiaosun','xiaoxue','xiaoliang','xiaochen'}
c = {'xiaosun','xiaoxue','xiaozhou','xiaoliu','xiaocheng'}
print(python | c)
print(python.union(c))
# 交集 intersection or &
print(80*'-')
print(python & c)
print(python.intersection(c))
# 差集 difference or - 例如，python - c 等于 python.difference(c) 等于 集合python有但c没有的
print(80*'-')
print(python.difference(c))
print(c - python)
# 对称差集 symmetric_difference or ^ 释义： 并集-交集 A∪B-A∩B
print(80*'-')
print(python ^ c)
print(python.symmetric_difference(c))
# == 判断是否相等
print(80*'-')
print(c == python)
# 父集 > >= issuperset a >= b 即为a是否为b的父集
print(80*'-')
print(python >= c)
print(python.issuperset(c))
# 子集 < <= issubset a<=b 即为a是否为b的子集
print(80*'-')
print(python <= c)
print(python.issubset(c))
print(160*'-')
print(" 需要掌握 ")
print(s_set)
# add 将以一个元素添加至集合 与之前的删除等一样，是一个操作无返回值
print(80*'-')
s_set.add('xiaoda')
print(s_set)
# remove 移除元素，元素不存在会报错
print(80*'-')
s_set.remove('daliang')
print(s_set)
# difference_update 释义：移除集合a中拥有的集合b的元素，如a=1,2,3 b=1,5,6,那么运算的结果为a = 2,3
# 与上买的都一样都是操作，不能直接输出
print(80*'-')
python.difference_update(c)
print(python)
# discard（抛弃） 也是去除，区别于remove ，discard不会报错，等于无操作
print(80*'-')
s_set.discard('daliang')
print(s_set)
# isdisjoint 交集为空的话返回true 判断两个集合是否有交集
print(80*'-')
a = {1,2,3,4}
b = {5,6,7,8}
c = {1,3,5,7}
print(a.isdisjoint(b))
print(a.isdisjoint(c))