- 列表 list[]
- 元祖 tuple()
- 字典 dict{}
- 集合 {}/set([])
- 列表(list)、元祖(tuple)、集合(set)，和字典(dictionary)对比总结
列表是Python中最基本的数据结构:
- 可以存放任意类型的对象
- list是有序的
>>> list1=[1,2,3] >>> list2=[3,2,1] >>> list1==list2 False
- 列表中的每个元素的都对应着一个索引来标记其位置，且索引从0开始,倒数是从-1开始
- 列表是可变对象，可以进行增删改
列表语法
可以存放任意类型的对象
>>> list = [1,'abc',[1,2,3],{'tt','yy'}]
>>> list
[1, 'abc', [1, 2, 3], {'tt', 'yy'}]
访问列表中的元素
列表中的每个元素的都对应着一个索引来标记其位置，且索引从0开始,倒数是从-1开始
列表名[索引] --索引对应的值
列表名[索引起始值:索引终止值:步长] --含起始值 不含终止值，步长不写默认缺省值为1
>>> list1 = ['a','b','c','d'] >>> list1[1] 'b' >>> list[-2] [1, 2, 3] >>> list1[1:3] ['b', 'c'] >>> list1[0:4:2] ['a', 'c']
有一种访问形式：列表名[索引：] --表示访问该索引(含)之后的所有元素
>>> list = [1,'abc',[1,2,3],{'tt','yy'}]
>>> list[1:]
['abc', [1, 2, 3], {'tt', 'yy'}]
列表的切片
列表名[起始值：终止值：步长] -含起始值 不含终止值，步长不写默认缺省值为1
列表的切片也是生成一个新的对象
>>> list1 = ['a','b','c','d'] >>> list1[1:3] ['b', 'c'] >>> list1[0:4:2] ['a', 'c']
列表的新增
- append : 添加元素到列表的末位
>>> list2 = [10,20,30,40] >>> list2.append(50) >>> list2 [10, 20, 30, 40, 50]
- insert: 添加元素到列表指定的位置
列表名.insert(指定插入到的下标，插入的值)
没有默认缺省值，必须两个参数都写
指定的下标可以大于当前列表最大下标，大于的话默认加在最后
>>> list3 = [1,2,3,4,5] >>> list3.insert(2,6) >>> list3 [1, 2, 6, 3, 4, 5] >>> list3.insert(22,7) >>> list3 [1, 2, 6, 3, 4, 5, 7]
列表值的修改
列表名[索引] = 要改成的值 --通过索引直接进行替换
>>> list4 = [1,2,3] >>> list4[0] = 11 >>> list4 [11, 2, 3]
删除列表中的元素
pop():默认删除列表最后一位的值，也可以指定位置进行删除
- 删除最后一个元素：pop()
>>> list5 = [4,5,6] >>> list5.pop() #会打印出删除的值 6 >>> list5 [4, 5]
- 通过索引进行删除：pop(索引)
>>> list6 = [4,5,6] >>> list6.pop(1) 5 >>> list6 [4, 6] >>>
- 指定的值删除：
remove(指定的值) 直接删除列表中指定的值;如果列表中有多个指定的这个值，只删除第一个
>>> list7 = [77,66,77,55] >>> list7.remove(77) >>> list7 [66, 77, 55]
- del 删除
del 列表名 —直接把列表删除了，慎用!
del 列表名(索引) —删除指定下标
>>> list8 = [1,2,3] >>> del list8[2] >>> list8 [1, 2] >>> del list8 >>> list8 Traceback (most recent call last): File "", line 1, in NameError: name 'list8' is not defined
列表的拼接
extend
列表1.extend(列表2)
>>> list9 = ['a','b'] >>> list10 = [11,22,22] >>> list9.extend(list10) >>> list9 ['a', 'b', 11, 22, 22] >>> list10 [11, 22, 22]
列表拼接字符串：会自动把字符串拆成一个列表再进行拼接
>>> list10 = [11,22,22] >>> str = 'abc' >>> list10.extend(str) >>> list10 [11, 22, 22, 'a', 'b', 'c']元祖 tuple()
- 元祖与列表类似也可以使用索引和切片，与列表用法相同
- 元祖是不可变对象，不能增删改
- 元祖是有序的
>>> t1=(1,2) >>> t2=(2,1) >>> t1==t2 False
元祖语法
tuple = () --创建空的tuple，直接写小看括号即可
tuple = (1,) --当元祖中只有一个值时，要加一个逗号，否则括号会被
当作运算符使用，可以通过 type()函数来查看类型
>>> tuple1=(1) >>> tuple2=(1,) >>> type(tuple1)>>> type(tuple2)
tuple = (2,3) --常规写法
>>> tuple=(2,3) >>> tuple (2, 3) >>> type(tuple)
元祖本质上也可理解为是列表，但是是不可变的列表，
>>> tuple=(100,200,'a','ss',[1,'f']) >>> tuple[1]=20 Traceback (most recent call last): File "", line 1, in TypeError: 'tuple' object does not support item assignment >>> tuple[4]=[1,2] Traceback (most recent call last): File " ", line 1, in TypeError: 'tuple' object does not support item assignment
元祖中的子元素可以包含列表
当tuple中的元素为可变的数据类型，从而使tuple“可变”
>>> tuple=(100,200,'a','ss',[1,'f']) >>> tuple[4][0]=5 >>> tuple (100, 200, 'a', 'ss', [5, 'f'])
tuple的删除
因为tuple是不可修改的，所以tuple中的元素也是不可删除的，但可以通过del关键字将tuple直接删除掉：
>>> tuple11=(1,2,3) >>> del tuple11 >>> tuple11 Traceback (most recent call last): File "", line 1, in NameError: name 'tuple11' is not defined
元祖的索引和切片
用法与列表一样，就不赘述了
元祖的拼接
因为元祖是不可变对象，拼接生成的是新的元祖
>>> t1=(1,2,3)
>>> t2=('a','b')
>>> t3=t1+t2
>>> t3
(1, 2, 3, 'a', 'b')
元祖与列表的转换
- tuple(list)函数：将list转换为tuple
>>> l = [1,2,3] >>> tuple(l) (1, 2, 3)
- list(tuple)函数：将tuple转换为list
>>> t = ('a','b','c')
>>> list(t)
['a', 'b', 'c']
字典 dict{}
字典是另一种可变的容器模型，且可存储任意类型对象:
- 字典以键值对的形式出现
>>> dict1={'A':'apple','y':'英语','c':[1,2.3]}
>>> dict1
{'A': 'apple', 'y': '英语', 'c': [1, 2.3]}
- 键必须是唯一的，不会重复，但值则不必：
当同样的键定义了几个值，只取最后一个值
>>> dict2={'a':1,'a':2}
>>> dict2
{'a': 2}
- 字典是无序的
>>> dict1={'a':1,'b':2}
>>> dict2={'b':2,'a':1}
>>> dict1==dict2
True
- 字典是可变对象，值可以取任何数据类型；但是键是不可变对象，所以只能存放不可变的数据类型：数字、字符串、元祖(但是子元素包含可变对象的元祖也不可作为键)
>>> dict3={1:'a','b':2,(1,'c',[2,3]):[1,2,3]}
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
>>> dict3={1:'a','b':2,(1,'c'):[1,2,3]}
>>> dict3
{1: 'a', 'b': 2, (1, 'c'): [1, 2, 3]}
访问字典中的元素
- 通过字典的key进行取值,如果key不存在就会报错
dict[key]
>>> dict4={'a':11,'b':22,'c':33}
>>> dict4['b']
22
>>> dict4['d']
Traceback (most recent call last):
File "", line 1, in
KeyError: 'd'
- 通过dict提供的get方法，如果key不存在，可以返回None，或者自己指定的value，兼容报错情况
>>> dict4={'a':11,'b':22,'c':33}
>>> dict4.get('e')
>>> print(dict4.get('e'))
None
>>> dict4.get('e',44)
44
- d.items() 打印所以键值对数据
- d.keys() 打印字典所有的key
>>> dict7={'a':1,'b':2,'c':3,'d':4}
>>> dict7.items()
dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
>>> dict7.keys()
dict_keys(['a', 'b', 'c', 'd'])
- 遍历字典中的键值对
>>> for key,value in dict7.items(): ... print(key,value) ... a 1 b 2 c 3 d 4
字典的新增和修改
字典的新增和修改语句是一样的：如果字典了已有键，则修改值；如果没有，则新增
>>> dict4={'a':1,'b':2,'c':3}
>>> dict4['a']=11
>>> dict4
{'a': 11, 'b': 2, 'c': 3}
>>> dict4['d']=33
>>> dict4
{'a': 11, 'b': 2, 'c': 3, 'd': 33}
update()：可添加多个键值对
>>> dict5={'a':1,'b':2}
>>> dict5.update({'c':'aaa','s':'sss'})
>>> dict5
{'a': 1, 'b': 2, 'c': 'aaa', 's': 'sss'}
删除字典的元素
可以删除字典的key和整个字典
del dict[键] / del dict
>>> dict6={'aa':11,'bb':22,'cc':33}
>>> del dict6['bb']
>>> dict6
{'aa': 11, 'cc': 33}
知识补充
- 判断一个对象是否在字典中，根据键判断，而不是根据值
>>> dict8={'abc':'abcdef'}
>>> print('abcdef' in dict8)
False
>>> print('abc' in dict8)
True
- json格式是非常像字典的字符串，但它不是字典；json的格式要求很严格
json主要就是存在于接口中
写法如下：
str = '''{
"a01": "apple"
"b01": "baby"
"c01": "cut"
}'''
>>> type(str)
看上去很像字典，其实不是字典，所以不能直接用字典的方法用来取键的值
需要把json先转为真正的字典，之后通过字典的取键的值的方式灵活取想要的值
json.loads(json名) --把json转化为字典
json.dump(字典名) --把字典转化为json
set集合是创建一个无序不重复元素集，可添加、删除数据，还可计算交集、差集、并集等
set语法
{}、set([])
>>> s={1,2,3}
>>> type(s)
>>> s
{1, 2, 3}
>>> s2=set([1,2,3])
>>> s2
{1, 2, 3}
set和dict的唯一区别仅在于没有存储对应的value，但set的原理和dict一样，所以同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”
>>> s=set([1,'a',[11,22],(33,44),{'a':1,'b':2}])
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
>>> s=set([1,'a',(33,44),{'a':1,'b':2}])
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'dict'
>>> s=set([1,'a',(33,44,[11,22])])
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
>>> s=set([1,'a',(33,44)])
>>> s
set元素的增删
- 添加元素： set.add(要添加的元素)：
添加数据，可以重复添加，但会被过滤掉
每次只能添加一个元素
>>> s=set([1,'a',(33,44)])
>>> s.add('b')
>>> s
{1, 'a', 'b', (33, 44)}
>>> s.add('c','d')
Traceback (most recent call last):
File "", line 1, in
TypeError: set.add() takes exactly one argument (2 given)
>>> s.add('c')
>>> s
{1, 'a', 'b', 'c', (33, 44)}
>>> s.add('b')
>>> s
{1, 'a', 'b', 'c', (33, 44)}
- 删除数据：set.remove(要删除的元素)
每次只能删除一个元素
删除不存在的元素会报错
>>> s=set([1,'a','b','c',(33,44)])
>>> s.remove('c')
>>> s
{1, 'a', 'b', (33, 44)}
>>> s.remove(1,'a')
Traceback (most recent call last):
File "", line 1, in
TypeError: set.remove() takes exactly one argument (2 given)
>>> s
{1, 'a', 'b', (33, 44)}
>>> s.remove(2)
Traceback (most recent call last):
File "", line 1, in
KeyError: 2
set的交集、差集、并集
类似数学的交集、并集、差集
>>> s1=set([1,2,'a','b'])
>>> s2=set([1,3,'aa','b'])
>>> s1&s2 #交集
{1, 'b'}
>>> s1|s2 #并集
{1, 'a', 2, 3, 'b', 'aa'}
>>> s1-s2 #差集
{'a', 2}
>>> s2-s1 #差集
{3, 'aa'}
列表(list)、元祖(tuple)、集合(set)，和字典(dictionary)对比总结
