python的列表，元组，字典及集合
列表
empty []//空列表
empty[0], empty[2] = empty[2], empty[0] //让第三个元素和第一个元素位置互换！
mylist=[1,2,3,4,5]
列表的切片如mylist[1:4]//包括第1个（人类世界中的第2个），也就是切片中第一个参数那个，但不包括结束那个，切片的第二个参数
mylist[0:2]//列表的切片，是创建一个新的列表，新列表的元素是由mylist列表的第0给元素到第1个元素构成，如mylist[0:2]其实相当于一个新列表[1,2],原列表是没有发生变化的！！
mylist[:3]//默认从0开 相当于列表[1,2,3]
mylist[2:]//默认到最后一个结束 相当于[3,4,5]
mylist[:]//相当于从0开始到最后一个结束，也就是复制了一个一模一样的新列表[1,2,3,4,5]
列表还有第三给参数，如：
mylist[0:3:2]//相当于[1,3]从0开始，到2结束，且每隔两个取一个
还可以这样
mylist[::-1]//相当于[5,4,3,2,1]
mylist[1:-1]//[2,3,4]从1开始到倒数第一个结束，不包括倒是第一个
切片易混淆的地方
list1 = [2,3,1,4] list2 = list1[:] list3 = list1 list1.sort() 结果list1[1,2,3,4] list2[2,3,1,4] list3[1,2,3,4] #原理就是 真正的拷贝要用切片，而list3 = list1 其实不过只是给list1这个列表起多给名字叫list3
//修改列表的元素
1：可以一个元素一个元素的修改
a = [1,2,3,"asd"] a[2] = "asdf" print(a) 结果 [1, 2, 'asdf', 'asd']
2：也可以几个元素一起修改
a = [1,2,3,"asd"] a[:2] = ["zxc",123] print(a) 结果 ['zxc', 123, 3, 'asd']
//可以一次删一个元素
a = [1,2,3,"asd"] del a[2] print(a) 结果 [1, 2, 'asd']
//也可以一次删除多个
a = [1,2,3,"asd"] del a[:2] print(a) 结果 [3, 'asd']
//将其他数据类型转换成列表
要想将其他数据类型转换成列表，则该数据类型必须是可迭代对象，用list()函数即可转换，内部原理其实是list()这个函数里面是用for循环，将其他数据类型进行迭代，然后将迭代得到的东西当成列表的一个个元素
a = "djhhwxhytlbz" a = list(a)//字符串是可迭代对象，将迭代的字符作为列表的一个个元素 print(a) 结果 ['d', 'j', 'h', 'h', 'w', 'x', 'h', 'y', 't', 'l', 'b', 'z'] a = 254 a = list(a) print(a) 结果 TypeError: 'int' object is not iterable//数字不是可迭代对象
//将列表转换成字符串
1：理所当然的想法
a = [1,2,3,"asd"] b = str(a) print(b,type(b)) 结果 [1, 2, 3, 'asd'] <class 'str'>//相当于转换成 "[1, 2, 3, 'asd']" 结果并没有如我们所想"123asd"
2：想要转换成"123asd"只能自己写for循环
a = [1,2,3,"asd"] s = "" for each in a: s += str(each) print(s) 结果 123asd
3：如果列表的元素全部是字符串时，想转换成我们所要的结果可以如下做法：
a = ["123", "asd"] s = "".join(a) print(s) 结果 123asd
列表是可以修改的，所以在使用方法时不需要一个新的变量来接收，因为它会在原基础上对列表进行修改
//append()方法，在列表后面添加一个新元素
a = ["123", "asd"] a.append(2) print(a) 结果 ['123', 'asd', 2]
//clear()方法，清空一个列表
a = ["123", "asd"] a.clear() print(a) 结果 [] //有一些小伙伴喜欢用a = []这种方法来清空列表，这样的做法是利用了python的垃圾回收机制，意思是当一个对象没有被变量指定时，python的垃圾回收机制会回收这个对象，但容易 //出问题，举个例子 a = ["123", "asd"] b = a a = [] print(a, b) 结果 [] ['123', 'asd']//因为还有b变量指定它，所以没有被回收，这种做法就有可能没有真正的清理掉某个列表
//copy()方法，拷贝一个新的一模一样的列表，浅拷贝
a = ["123", "asd"] b = a.copy() print(a, b) 结果 ['123', 'asd'] ['123', 'asd']
//count()方法，计算列表中某个元素的个数
a = ["123", "asd", "djh", "djh"] b = a.count("djh") print(a, b) 结果 2
//extend()方法，参数必须是一个可迭代对象，原理是对参数进行迭代，对该对象的每一个迭代对象进行append()方法加入原列表中
a = [123, "asd", "djh"] a.extend([1,2,"大帅哥"]) print(a) 结果 [123, 'asd', 'djh', 1, 2, '大帅哥'] a = [123, "asd", "djh"] a.extend("大帅哥") print(a) 结果 [123, 'asd', 'djh', '大', '帅', '哥']
//index()方法，返回某个元素的下标，有三个参数，第一个参数要查找的元素，第二给参数查找的起始位置，第三个参数查找的结束位置
a = [123, "asd", "djh", "djh"] b = a.index("asd") print(b) 结果 1 a = [123, "djh", "asd", "djh"] b = a.index("djh") print(b) 结果 1//有多个时返回最左边的那个 a = [123, "djh", "asd", "djh"] b = a.index("djh",a.index("djh")+1,4) print(b) 结果 3//指定范围，2--3
//insert()方法，在指定位置插入元素
a = [123, "djh", "asd", "djh"] a.insert(2,"大帅哥") print(a) 结果 [123, 'djh', '大帅哥', 'asd', 'djh']//在2这个位置插入“大帅哥”
//pop()方法，删除指定下标的元素，默认是最后一个元素，并且返回删除的元素的值
a = [123, "djh", "asd", "djh"] b = a.pop(0) print(a,b) 结果 [ 'djh', 'asd', "djh"] 123 a = [123, "djh", "asd", "djh"] b = a.pop() print(a,b) 结果 [123, 'djh', 'asd'] djh
//remove()方法，删除已知值的元素，不会返回该值
a = [123, "djh", "asd", "djh"] a.remove("djh") print(a) 结果 [123, 'asd', 'djh']//有多个个时删除最左边的那个
//reverse()方法，将列表翻转
a = [123, "djh", "asd", "djh"] a.reverse() print(a) 结果 ['djh', 'asd', 'djh', 123]//当然也可以a = a[::-1]进行翻转
//sort()方法 ，排序，默认从小到大，sort(func,key,reverse)有三个参数，第一个是用啥算法去排，默认是归并，第二个是关键字，第三个是翻转，默认是reverse=False, 也就是a.sort()啥参数都没给，默认从小到大又不翻转，那结果就是从小到大咯，如果reserve=True,默认从小到大，翻转，结果就是从大到小咯
a = [123, 11, 14, 22, 41, 9, 0] a.sort() print(a) 结果 [0, 9, 11, 14, 22, 41, 123] a = [123, 11, 14, 22, 41, 9, 0] a.sort(reverse=True) print(a) 结果 [123, 41, 22, 14, 11, 9, 0]
列表可以比较大小，如:
list1=[123,8534] list2=[142,532] list1<list2 比较方式和字符串比较相似，先比较第一个，如果比较出结果了就不看第二个了，否则继续比较第二个，如果一直比较下去直到有一个列表结束了还没出结果，则元素多的那个列表较大，如[123] <[123,222]
列表也可以相加:
a = [123,23] b = [124] c=a+b//[123,23,124]
还可以乘：
a=[123]
a*=3//[123,123,123]
还有的常用操作:
a=[1,2,3,4,[5,6,7]]
>>>3 in a
True
>>>5 in a
False
>>>5 in a[4]
a = [1,1,2,3,4,5]
>>>len(a)//返回列表的元素个数
>>>6
元组
元组其实和列表很像，可以这样认为，元组是冻结的列表，元组的一级元素不可以被修改(如果元组里有列表元素，则列表内部可以修改)，不可以被删除，也不可以增加，也支持切片，元组是可迭代对象故可以作为 join()和extend()的实参，也可以将其他可迭代对象转换成元组，元组只有两个方法---count()和index() 这里不再重复，总而言之，除了没有列表那么多的方法和元素不可改变删除增加外，其余的一模一样
字典
字典的key不可以是字典，列表其余的都可以，value可以是任意类型 key为bool型的话相当于key是0或1
字典的key必须是唯一的，不可变的，所以列表才不可以作为key，如果不唯一只可以存留其中一个
a = {"123":123,1:"sdf","a":True,"a":"Ss"}
print(a)
结果
{'123': 123, 1: 'sdf', 'a': 'Ss'}
a = {"123":123,1:"sdf","a":True,True:"Ss"}
print(a)
结果
{'123': 123, 1: 'Ss', 'a': True}
字典是无序的，每一次的顺序都不一样
索引是不能索引下标的，因为无序呀！只能索引key
支持del删除操作
a = {"123":123,1:"sdf","a":True}
del a["123"]
print(a)
结果
{1: 'sdf', 'a': True}
支持 for循环不支持while循环，默认迭代是迭代key，也可以自己限定是迭代key或者value或者键值对
a = {"123":123,1:"sdf","a":True}
for each in a:
print(each)
结果
123
1
a
a = {"123":123,1:"sdf","a":True}
for each in a.values():
print(each)
结果
123
sdf
True
a = {"123":123,1:"sdf","a":True}
for each in a.items():
print(each)
结果
('123', 123)//结果是二元组
(1, 'sdf')
('a', True)
a = {"123":123,1:"sdf","a":True}
for each1,each2 in a.items():
print(each1,each2)
结果
123 123
1 sdf
a True
有5种创建方法：
1：用字典的标志符创建字典
>>>d = {1: 2, 3: 4, 'a': 2}//{}这个大括号是字典的标志符
2:用dict()函数创建字典，与用list(),创建列表，用tuple()创建元组一样，该函数只可以有一个参数
>>>d = dict( [(1,2), (2,3), ('a',2), ('c',3)] )//传一个参数，该参数是列表，列表的元素是二元组,当然，该参数也可以是元组，不过无论是列表还是元组，他们的元素最好是二元组，不要是二元列表，，，关键字是数字或者字符串都可以用该方法创建
>>>d = dict(zip((1, 2, 'a'), (1,2,3))) //里面的参数是zip()函数，zip()函数是啥自己去复习
>>>d = dict({1: 2, 3: 4, 'a':2})//参数直接就是一个字典，就如同list([1,2,3])这个一样，虽然看起来是多此一举，不过这样定义可以方便阅读，直接就是dict字典
>>>d = dict(a=1, b=2, c=3)//这个比较特殊，看起来参数好像不止一个，但这个是专门用来当关键字是字符串时定义字典用的,因为它有二星收集参数，所以它内部会自己打包成字典，而打包成字典的的key只能是字符串
//clear()清除一个字典，让其变成空字典，有的人喜欢让该变量指向一个空字典来清除旧字典，这个方法不好，因为他是利用了python垃圾清理机制来实现的，这样效率不高且容易出问题，所谓python的垃圾清理机制，其实就是，将一个没有被变量指定的值回收，但如果有变量指定，就不回收，如
d = {'a': 1, 'b': 2, 1: 'c'}
d = {}
print(d)
结果
{}//这里的{'a': 1, 'b': 2, 1: 'c'}这个原本被变量d指定，但当变量d重新指定一个空字典时，{'a': 1, 'b': 2, 1: 'c'}就没有变量指定了，就会被回收
d = {'a': 1, 'b': 2, 1: 'c'}
b = d
d = {}
print(d)
print(b)
结果
{}
{'a': 1, 'b': 2, 1: 'c'}
//b = d时，是将b也指向{'a': 1, 'b': 2, 1: 'c'}，那d指向新的东西时，{'a': 1, 'b': 2, 1: 'c'}还有被变量指定，即b，所以不会被回收
所以，当要清理一个字典时，一定一定一定要用clear()
//copy()，复制一个字典赋给一个新的变量，浅赋值
d = {'a': 1, 'b': 2, 1: 'c'}
b = d.copy()
print(d)
print(b)
结果
{'a': 1, 'b': 2, 1: 'c'}
{'a': 1, 'b': 2, 1: 'c'}
//fromkeys()方法，是静态方法，相当于c++里的静态成员函数用类名调用，批量生成字典的项,有两个参数，第一个参数是关键字，第二个参数是值，第一个参数必须要自己输入,可以是列表元组和range()等，第二个参数可以不输入，默认是None,fromekeys()不会改变原字典，而是创建一个新的字典并返回
d = dict.fromkeys([1,2,3]) print(d) 结果 {1: None, 2: None, 3: None} d = dict.fromkeys([1,2,3],"number") print(d) 结果 {1: 'number', 2: 'number', 3: 'number'} d = dict.fromkeys([1,2,3],(1,2,3))print(d) 结果 {1: (1, 2, 3), 2: (1, 2, 3), 3: (1, 2, 3)} 是不是惊呆了，你要记住，fromkeys()函数是将第二个参数看成一个整体，不管你是列表元组字符串之类的，它都会将其看为一个整体，并将该整体作为第一个参 数每个关键字的值！如上面第二三个例子
//get()方法，平时用[]这个运算符访问字典时，如果没找到则报错，用get()函数则不报错，甚至可以自己指定没找到时返回什么
a = {"1":2, "a":2, 1:"s"}
print(a["b"])
结果
Traceback (most recent call last):
File "C:/python编程/2.py", line 192, in <module>
print(a["b"])
KeyError: 'b'
a = {"1":2, "a":2, 1:"s"}
print(a.get("b"))
结果
None
a = {"1":2, "a":2, 1:"s"}
print(a.get("b",111))
结果
111
a = {"1":2, "a":2, 1:"s"}
print(a.get("a",111))
结果
2//找得到自然就返回找到的那个，忽略找不到时返回的那个
//pop()方法，删除指定的项，并放回该项的值，
a = {"1":2, "a":2, 1:"s"}
b = a.pop(1)
print(a,b)
结果
{'1': 2, 'a': 2} s
a = {"1":2, "a":2, 1:"s"}
b = a.pop("b")
print(a,b)
结果
Traceback (most recent call last):
File "C:/python编程/2.py", line 192, in <module>
b = a.pop("b")
KeyError: 'b'//删除不存在的项时，会报错
a = {"1":2, "a":2, 1:"s"}
b = a.pop("b","不存在")
print(a,b)
结果
{'1': 2, 'a': 2, 1: 's'} 不存在//如果指定了返回值“不存在”，如果真是不存在该项而你有删除的话，就不报错，返回你指定的值，这里是“不存在”
a = {"1":2, "a":2, 1:"s"}
b = a.pop(1,"不存在")
print(a,b)
结果
{'1': 2, 'a': 2} s//如果存在自然就忽略你指定的默认不存在时的返回值，所以一般都是建议用pop()方法时，加上默认的不存在时的返回值，这样就可以不报错
//popitem()方法，不可以那指定删除哪个项，随机删除（反正我只看过是删除最后一个项），返回该项
a = {"1":2, "a":2, 1:"s"}
b = a.popitem()
print(a,b)
结果
{'1': 2, 'a': 2} (1, 's')
a = {"1":2, "a":2, 1:"s"}
k,v = a.popitem()
print(a,k,v)
结果
{'1': 2, 'a': 2} 1 s
//setdefault()方法，两个参数，第一个是key第二个是value，如果已经存在该key则不修改并且返回已经存在的该key对应的值，如果不存在该key则添加该键值对，并且返回该键值对的值
a = {"1":2, "a":2, 1:"s"}
b = a.setdefault(3,"x")
print(a,b)
结果
{'1': 2, 'a': 2, 1: 's', 3: 'x'} x
a = {"1":2, "a":2, 1:"s"}
b = a.setdefault("a","x")
print(a,b)
结果
{'1': 2, 'a': 2, 1: 's'} 2
//update()方法，更新一个字典，如果已经存在该key则修改该key对应的值，如果不存在则添加该键值对
a = {"1":2, "a":2, 1:"s"}
a.update({"1":3,4:"X"})
print(a)
结果
{'1': 3, 'a': 2, 1: 's', 4: 'X'}//传一个参数，一般以传一个字典的方法，该字典包含多个键值对
a = {"1":2, "a":2, 1:"s"}
a.update(a="b",c="T")
print(a)
结果
{'1': 2, 'a': 'b', 1: 's', 'c': 'T'}//可以传多个参数，因为有二星收集参数，最后这些参数会被打包成一个字典，不过貌似这种要
后期打包成字典的方法，他的key只能是
字符串
集合
集合的元素必须是不可变类型的，如字符串，数字，元组。 列表，字典是可变类型，故不可以
集合是无序的，故不可以用下标索引来访问，貌似只可以用in访问，且元素不可重复，即使定义时有重复的，最后python会只留下一个
集合的定义，和list(),tuple()其实差不多，set()也是只可以有一个可迭代的参数
s = set("hello") print(s) 结果 {'e', 'l', 'o', 'h'} s = set([1,2,3,1,1,2,3,1]) print(s) 结果 {1,2,3}
//add()方法，往集合中添加元素
s = set([1,2,3,1,1,2,3,1]) s.add(4) print(s) 结果 {1,2,3,4}
//clear()方法，清空集合，注意事项不再重复
//copy()方法，复制一份新的
//pop()方法，随机删除一个元素，没有参数
//remove()方法，删除一个指定的元素，如果没有这个元素则报错
s = set([1,2,3,1,1,2,3,1]) s.remove(2) print(s) 结果 {1, 3}
//discard()方法，和remove一模一样，除了如果不存在指定的要删除的元素discard()不报错而remove()报错外没啥区别
//intersection()方法，求交集
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s.intersection(a))
结果
{2, 4, 5}
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s&a)//相当于c++里的重载运算符
结果
{2, 4, 5}
//union()方法，求并集
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s.union(a))
结果
{0, 1, 2, 3, 4, 5, 7, 8, 9}
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s|a)//和并集一样，相当于重载运算符
结果
{0, 1, 2, 3, 4, 5, 7, 8, 9}
//difference()差集，我有他没有的，也就是说减去他有的剩下我独有的
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s.differeance(a))
结果
{1，3}
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s-a)
结果
{1，3}
//symmetric_difference()方法，交叉补集，也就是(a-b)并上(b-a)，就是各自独有的东西并起来
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s.symmetric_difference(a))
结果
{0, 1, 3, 7, 8, 9}
s = {1,2,3,4,5,1,2}
a = {2,5,4,7,8,9,0}
print(s^a)
结果
{0, 1, 3, 7, 8, 9}
//update()方法，更新多个值，参数是一个可迭代对象 集合也可以
s = {1,2,3,3}
s.update({2,5,3})
print(s)
结果
{1, 2, 3, 5}
//isdisjoint()方法，判断两个集合中是否有相同的元素，没有则真否则假
s = {1,2,3,3}
b = {"a","s","x"}
print(s.isdisjoint(b))
结果
True
//issubset()方法，判断是否是另一个集合的子集
s1 = {1,2,3,4}
s2 = {1,2,3}
print(s2.issubset(s1))
结果
True//s2是s1的子集
s1 = {1,2,3,4}
s2 = {1,2,3}
print(s2<=s1)//子集 <=
结果
True//s2是s1的子集
s1 = {1,2,3,4}
s2 = {1,2,3}
print(s1.issubset(s2))
结果
False
//issuperset()方法，判断是否是另一个集合的父集
s1 = {1,2,3,4}
s2 = {1,2,3}
print(s1.issuperset(s2))
结果
True
s1 = {1,2,3,4}
s2 = {1,2,3}
print(s1>=s2)//父集 >=
结果
True
s1 = {1,2,3,4}
s2 = {1,2,3}
print(s2.issuperset(s1))
结果
False
集合是可变的，虽然元素不可以修改，但是可以增加和删除所以是可变的
但有的时候是要不可以增加和删除元素的集合，所以有了冷冻的集合 frozenset() 不可以用那些set()的方法了
