一 列表类型内置方法
1.作用：存在多个元素
2.定义方式：[]内用逗号隔开任意数据类型的元素
3.方法
4.多个值or一个值：多个值
5.有序or无序：有序
6.可变or不可变：可变
name_list = ['jack','engo','nick']
s_list = list('sdfa')
print(s_list)
['s', 'd', 'f', 'a']
3.方法：
（1）按索引取值：正向取值+反向取值，既可取也可以存
name_list = ['jack','engo','nick','amy']
print(name_list[2]) # 打印索引为2的元素
print(name_list[-1]) # 打印索引为-1的元素
nick
amy
（2）切片
print(name_list[1:3]) # 打印索引为1到3之间的元素
print(name_list[-2:]) # 打印最后2个元素
['engo', 'nick']
['nick', 'amy']
（3）len 长度
print(len(name_list)) # 获取name_list的字符串长度
4
（4）in 和 not in
print('jack' in name_list) # 'jack'在name_list中
print('jack' not in name_list) # 'jack'不在name_list中
True
False
（5）append 追加
用于在列表末尾添加新的对象，只接受一个参数，参数可以是任何数据类型，被追加的元素在List中保持着原结构类型，此元素如果是一个list，那么这个list将作为一个整体进行追加
name_list = ['jack','engo','nick']
name_list.append('helen') # 在列表最后添加‘helen’
name_list.append(['helen','aym']) #在列表最后添加列表['helen','aym']
print(name_list)
['jack', 'engo', 'nick', 'helen', ['helen', 'aym']]
（6）extend
将一个列表中每个元素分别添加到另一个列表中，只接受一个参数；extend()相当于是将list B 连接到list A上,列表A中存在的元素也会添加
name_list = ['jack','engo','nick']
name = ['aym','helen','egon']
name_list.extend(name) #将列表‘name’添加到‘name_list’后面
print(name_list)
['jack', 'engo', 'nick', 'aym', 'helen', 'egon']
（7）insert
将一个元素插入到列表中，但其参数有两个（如insert(1,"g")），第一个参数是索引点，即插入的位置，第二个参数是插入的元素
name_list = ['jack','engo','nick']
name_list.insert(1,'aym') # 将‘aym’添加到索引为1的位置
print(name_list)
['jack', 'aym', 'engo', 'nick']
（8）del
按照索引删除字符，返回值不可用给其他变量
del(name_list[2])
print(name_list)
['jack', 'engo', 'helen']
（9）pop
按照索引删除字符，返回值可以给其他变量，返回的是你弹出的那个数值
默认删除最后一个值,删除指定索引的值
name_list = ['jack','engo','nick','aym','helen']
name_list.pop() # 删除‘helen’
name_list.pop(-2) # 删除‘nick’
print(name_list)
['jack', 'engo', 'aym']
（10）remove
删除首个字符符合条件的元素，并不能删除特定的索引
name_list = ['jack','engo','nick','aym','helen']
name_list.remove('helen') # 删除最后一个元素
print(name_list)
['jack', 'engo', 'nick', 'aym']
（11）for 循环
（12）count
用于统计字符串里某个字符出现的次数。
name_list = ['helen','jack','engo','nick','aym','helen','helen','helen']
print(name_list.count('helen')) # 统计‘helen’出现的次数
4
4
（13）sort
用于对原列表进行排序，排序结果返回原列表；如果指定参数，则使用比较函数指定的比较函数
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）
name_list = ['jack','engo','nick','aym','helen']
name_list.sort() # 已首字母进行升序排序（默认）
print(name_list)
name_list = ['jack','engo','nick','aym','helen']
name_list.sort(reverse = True)
print(name_list) # 已首字母进行降序排序
['aym', 'engo', 'helen', 'jack', 'nick']
['nick', 'jack', 'helen', 'engo', 'aym']
（14）reverse
用于反向列表中元素(反向排序)
name_list = ['jack','engo','nick','aym','helen']
name_list.reverse() # 反向排序
print(name_list)
['helen', 'aym', 'nick', 'engo', 'jack']
（15）index
从左向右寻找子序列的位置
name_list = ['jack','engo','nick','aym','helen']
print(name_list.index('nick'))
2
（16）clear
clear() 函数用于清空列表，类似于 del a[:]
name_list = ['jack','engo','nick','aym','helen']
name_list.clear() # 情况name_list的内容
print(name_list)
[]
二 元祖类型内置方法
1.作用：类似于列表，可存不可取
2.定义方式：
tup1 = ('Google', 'Runoob', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d"; # 不需要括号也可以
3.方法
（1）索引取值
（2）切片
（3）长度
（4）成员运算
（5）for循环
（6）count
（7）index
4.多个值or一个值：多个值
5.有序or无序：有序
6.可变or不可变：无可变不可变这一说
三 字典类型的内置方法
1.作用：值太多列表存容易，取麻烦时使用字典
2.定义方式：
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
3.方法：
4.多个值or一个值：多个值
5.有序or无序：无序
6.可变or不可变：可变
（1）按键取值
按key键取值，可存可取
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict['Class']) # 取出‘Class’的值·
First
（2）len
计算字典元素个数，即键的总数
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(len(dict))
3
（3）key，valuses，items
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict.items())
print(dict.keys())
print(dict.values())
dict_items([('Name', 'Runoob'), ('Age', 7), ('Class', 'First')])
dict_keys(['Name', 'Age', 'Class'])
dict_values(['Runoob', 7, 'First'])
（4）for循环
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
for k, v in dict.items():
print(k, v)
Name Runoob
Age 7
Class First
（5）in 和 not in
in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print('Class' in dict)
False
（6）pop
删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict.pop('Name'))
print(dict)
Runoob
{'Age': 7, 'Class': 'First'}
（7）fromkeys
默认把给定列表内的元素取出来当成key,然后使用一个默认value新建一个字典
dic = dict.fromkeys(['a','b','c','d','e'], 1) # 指定值
print(dic)
x = dict.fromkeys(('key1', 'key2', 'key3')) # 不指定值
print(x)
{'a': 1, 'b': 1, 'c': 1, 'd': 1, 'e': 1}
{'key1': None, 'key2': None, 'key3': None}
（8）setdefault
如果字典中有该key的话,则key对应的值不变;如果没有,则增加
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict.setdefault('搜索','google') # dict中增加'搜索':'google'
print(dict)
dict.setdefault('Name','nick') # dict中已存在‘name’的给定值，不会发生改变
print(dict)
{'Name': 'Runoob', 'Age': 7, 'Class': 'First', '搜索': 'google'}
{'Name': 'Runoob', 'Age': 7, 'Class': 'First', '搜索': 'google'}
（9）get
get() 函数返回指定键的值，如果值不在字典中返回默认值，也可以返回给定的值
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print(dict.get('Age')) # 找到返回指定键的值
print(dict.get('name')) # 没找‘name’则返回默认值
print(dict.get('name','NO')) # 没找‘name’则返回给定的值‘NO’
7
None
NO
（10）update
把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里
dict = {'Name': 'Runoob', 'Age': 7}
dict2 = {'Sex': 'female' }
dict.update(dict2)
print(dict)
{'Name': 'Runoob', 'Age': 7, 'Sex': 'female'}
（11）del
删单一的元素也能清空字典
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除‘name’及对应的值
print(dict)
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict # 清空dict的所以内容
print(dict)
{'Age': 7, 'Class': 'First'}
<class 'dict'>
四 集合类型内置方法
1.作用：存多个值，为了集合之间做运算
2.定义：可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
parame = {value1,value2,value3}
创建集合： value = set()
print(value)
3.方法：
4.多个值or一个值：多个值
5.有序or无序：无序
6.可变or不变：可变
（1）去重
列表转集合，会自动去重，但也会打乱列表元素原有的顺序
list = [0,0,1,2,1,3,5,5,4,8,6,7]
list1 = set(list)
print(list1)
{0, 1, 2, 3, 4, 5, 6, 7, 8}
（2）交集
intersecion() ；交集也可以用 & 表示 ：set1 & set2
list_set = set([1,5,6,7,0,0,4,5,6])
print(list_set)
list_set2 = set([23,5,78,9,4,56])
print(list_set2)
print(list_set.intersection(list_set2))
{0, 1, 4, 5, 6, 7}
{4, 5, 9, 78, 23, 56}
{4, 5}
（3）并集
union() ;并集也可以用 | 表示： set1 | set2;
list_set = set([1,5,6,7,0,0,4,5,6])
print(list_set)
list_set2 = set([23,5,78,9,4,56])
print(list_set2)
print(list_set.union(list_set2))
{0, 1, 4, 5, 6, 7}
{4, 5, 9, 78, 23, 56}
{0, 1, 4, 5, 6, 7, 9, 78, 23, 56}
（4）差集
(就是这个集合有，而另一个集合没有的） difference() ;差集也可以用 - 表示: set1 - set2
list_set = set([1,5,6,7,0,0,4,5,6])
print(list_set)
list_set2 = set([23,5,78,9,4,56])
print(list_set2)
print(list_set.difference(list_set2))
{0, 1, 4, 5, 6, 7}
{4, 5, 9, 78, 23, 56}
{0, 1, 6, 7}
（5）对称差级
对称差集(相当于并集减去交集) symmetric_difference();对称差集也可以用 ^ 表示 ；set1 ^ set2
list_set = set([1,5,6,7,0,0,4,5,6])
print(list_set)
list_set2 = set([23,5,78,9,4,56])
print(list_set2)
print(list_set.symmetric_difference(list_set2))
{0, 1, 4, 5, 6, 7}
{4, 5, 9, 78, 23, 56}
{0, 1, 7, 6, 23, 56, 9, 78}
（6）父级
父集 issuperset()；父集也可以用 >= 表示； set1 >= set2
list_set = set([1,5,6,7,0,0,4,5,6])
print(list_set)
list_set2 = set([23,5,78,9,4,56])
print(list_set2)
print(list_set.issuperset(list_set2))
{0, 1, 4, 5, 6, 7}
{4, 5, 9, 78, 23, 56}
False
（7）子集
子集 issubset()；子集也可以用 <= 表示； set1 <= set2
list_set = set([1,5,6,7,0,0,4,5,6])
print(list_set)
list_set2 = set([23,5,78,9,4,56])
print(list_set2)
print(list_set.issubset(list_set2))
{0, 1, 4, 5, 6, 7}
{4, 5, 9, 78, 23, 56}
False
（8） ==
判断2个集合是否相等
list_set = set([1,5,6,7,0,0,4,5,6])
print(list_set)
list_set2 = set([23,5,78,9,4,56])
print(list_set2)
print(list_set == (list_set2))
{0, 1, 4, 5, 6, 7}
{4, 5, 9, 78, 23, 56}
False
拷贝
如果l2是l1的拷贝对象，则l1内部的任何数据类型的元素变化，则l2内部的元素也会跟着改变，因为可变类型值变id不变
浅拷贝
如果l2是l1的浅拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，则l2会跟着改变
深拷贝
如果l2是l1的深拷贝对象，则l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1的变化而变化