一、列表的常用操作及内置方法
1、用途：按照索引存放多个任意类型的值，索引反映的是位置/顺序
2、定义方式：在[]内用逗号分割开多个任意类型的元素
#数据类型转换
res=list("hello")3[‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘] # res=list({"k1":1,"k2":2,"k3":3})3[‘k1‘, ‘k2‘, ‘k3‘] print(res)
3、常用操作+内置的方法
===============3.1 优先掌握的操作===============
1、按索引存取值(正向存取+反向存取)：即可以取可以改值,不能加值
2、切片(顾头不顾尾，步长)
2.1 浅copy：
l1 = [11,22,[66,77]] l2=l1.copy() print(id(l1[0]),id(l1[1]),id(l1[2])) print(id(l2[0]),id(l2[1]),id(l2[2]))#与上一横id相同
2.2 deepcopy:
l1 = [11,22,[66,77]] from copy import deepcopy#深拷贝要引用的模块 l3=deepcopy(l1) print(id(l3[0]),id(l3[1]),id(l3[2])) l1[2][0]=6666 print(l1) print(l3)
# 了解：
res=l1[-1:-4:-1] res=l1[::-1] print(res)#步长与切片方向都要一致
3、长度
l1 = [11,22,[66,77]] print(len(l1))
4、成员运算in和not in
l1 = [111,22,[66,77]] print([66,77] in l1)#[66,77]是个整体 print(66 in l1) print(66 not in l1)
5、追加append
l1=[11,222] l1.append(33) l1.append(44) l1.append([55,66]) print(l1)
6、insert插入
l1 = [111,22,[66,77]] l1.insert(1,"aaa")#在索引1的前面插入‘aaa‘ print(l1)#[11, ‘aaa‘, 22, [66, 77]]
7、删除
l1=[11,222,[1,2]] #6.1 万能删除，没有返回值，代表的是单纯的删除 # del l1[0] # print(l1) #6.2 指定元素删除,没有返回值，代表的是单纯的删除 # res=l1.remove([1,2]) # print(l1) # print(res) #6.3 指定索引删除，有返回值，代表的是取走操作 # res=l1.pop(1) # print(l1) # print(res)
8、循环
l1=[11,222,[1,2]] for x in l1: print(x)
===============3.2 需要掌握的操作===============
1、clear
l1.clear()
2、append extend
extend内置for循环，而append没有
l2=[444,555] for item in l2: l1.append(item) print(l1)#[11, 22, 333, 333, 333, 444, 555] l1.extend(l2) print(l1)#[11, 22, 333, 333, 333, 444, 555, 444, 555] l1.extend("hello")#[11, 22, 333, 333, 333, 444, 555, 444, 555, ‘h‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘] print(l1)
3、count
l1=[11,22,333,333,333,] print(l1.count(333333333))#0计数为0 print(l1.count(22)) #1计数为1
4、index
l1=[11,22,333,333,333,] # res=l1.index(333,0,2)#查找不到报错 # res=l1.index(444)#查找不到报错 print(res)
5、reverse
l1=[11,22,"aaa",‘bbb‘] l1.reverse() # l1=l1[::-1]#也可以反转 print(l1)#[‘bbb‘, ‘aaa‘, 22, 11]
6、sort 排序，默认从小到大排，除非定义
l1 = [11, 22, "aaa", ‘bbb‘] l1 = [-3,99,12,-5,93] l1.sort(reverse=True) print(l1)
列表总结：
存多个值，有序，可变类型
二、元组的常用操作及内置方法
1、元组就是一个不可变的列表
2、用途: 按照索引存放多个任意类型的值，索引反应的是位置/顺序
3、定义方式：在()内用逗号分隔开多个任意类下的值/元素
# 强调:当元组内只有一个元素时，必须加逗号
# 类型转换
tuple(所有可以被for循环遍历的类型)
#空元组 t=()
4、常用操作+内置的方法
=============优先掌握的操作=============
1、按索引取值(正向取+反向取)：只能取
2、切片(顾头不顾尾，步长)
3、长度
4、成员运算in和not in
5、循环
============需要掌握的操作==============
元组总结：
存多个值，有序，不可变
三、字典的常用操作及内置方法
1、用途：按key:value的形式存放多个任意类型的value，key反映的是value的属性
2、定义方式：在{}内用逗号分隔开多个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常是字符串类型
# 若 key重复，只保留一个
# 空字典 d={}
# 类型转换
#列表转换为字典 l=[("name","egon"),("age",18),["gender","male"]] res=dict(l) print(res)
d=dict(x=1,y=2,z=3) print(d)
dic1={}.fromkeys(["name",‘age‘,"gender"],None)
print(dic1)#{‘name‘: None, ‘age‘: None, ‘gender‘: None}
dic2={}.fromkeys("hello",None)
print(dic2)#{‘h‘: None, ‘e‘: None, ‘l‘: None, ‘o‘: None}
3、常用操作+内置的方法
============优先掌握的操作============
1、按key存取值：可存可取
d={‘k1‘:111}#取
print(d[‘k1‘])#111
d[‘k2‘]=222#存
print(d)#{‘k1‘: 111, ‘k2‘: 222}
2、长度len
d={‘k1‘:111,‘k2‘:222}
print(len(d))#2
3、成员运算in和not in ====》说的是key
d={‘k1‘:111,‘k2‘:222}
print(‘k1‘ in d)#True
print(111 in d)#False
4、删除
d={‘k1‘:111,‘k2‘:222}
#6.1 万能删除，没有返回值，代表的是单纯的删除
# del d[‘k1‘]
# print(d)
#6.2 随机删,返回一个元组
# res=d.popitem()
# print(d)
# print(res)
#6.3 指定key删除，有返回值，代表的是取走操作
# res=d.pop(‘k1‘)
# print(d)
# print(res)
5、键keys()，值values()，键值对items()
#python2中 """ >>> d={‘k1‘:111,‘k2‘:222} >>> d.keys() [‘k2‘, ‘k1‘] >>> d.values() [222, 111] >>> d.items() [(‘k2‘, 222), (‘k1‘, 111)] """
6、循环
d={‘k1‘:111,‘k2‘:222}
for k in d:
print(k)
for v in d.values():
print(v)
for k,v in d.items():
print(k,v)
keys=[]
for k in d:
keys.append(k)
print(keys)#[‘k1‘, ‘k2‘]
print(d)#{‘k1‘: 111, ‘k2‘: 222}
7、
d={‘k1‘:111,‘k2‘:222}
keys=list(d.keys())
print(keys)#[‘k1‘, ‘k2‘]
该类型总结：
存多个值，无序，可变类型
原文：https://www.cnblogs.com/guojieying/p/13295364.html