python处理列表中字典_Python——列表、元祖、字典、集合的基本操作

列表

1. 列表——增

（1）append

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']

li.append('nihao')print(li) #['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰', 'nihao']

li.append(1)print(li) #['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰', 'nihao', 1]

print(li.append('hello')) #None：无返回值，li.append()只是一个方法、动作

print(li) #['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰', 'nihao', 1, 'hello']

（2）insert

li = ['xcsd','cdc',[1,5,2],'eht','辛辰']

li.insert(3,'bxb')print(li) #['xcsd', 'cdc', [1, 5, 2], 'bxb', 'eht', '辛辰']

（3）extend

li = ['xcsd','cdc',[1,5,2],'eht','辛辰']

li.extend('cc') #['xcsd', 'cdc', [1, 5, 2], 'bxb', 'eht', '辛辰', 'c', 'c']

print(li)

li.extend([1,2,3])print(li) #['xcsd', 'cdc', [1, 5, 2], 'bxb', 'eht', '辛辰', 'c', 'c', 1, 2, 3]

#报错：数字不能迭代

li.extend(123)print(li) #TypeError: 'int' object is not iterable

应用实例：

#连续输入员工姓名，输入Q/q退出并打印列表

whileTrue:

username= input("请输入要添加的员工姓名：")if username.strip().upper() == 'Q':breakli.append(username)print(li)print(li)

运行结果：

2. 列表——删

(1) remove：按照元素删除

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']

li.remove('xcsd')print(li) #['cdc', [1, 5, 2], 'eht', '辛辰']

(2) pop：按照索引删除——有返回值

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']

name= li.pop(1) #有返回值

print(name,li) #cdc ['xcsd', [1, 5, 2], 'eht', '辛辰']

name = li.pop() #不写索引则默认删除最后一个

print(name,li) #辛辰 ['xcsd', [1, 5, 2], 'eht']

(3) clear： 清空

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']

li.clear()print(li) #[]

(4) del ：删除

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']#del li[2:]#print(li) #['xcsd', 'cdc']

del li #删除之后，已经不存在，打印报错

print(li) #NameError: name 'li' is not defined

(5) 循环删除

li = [11,22,33,44,55]for i inrange(len(li)):print(i)delli[0]print(li)

3. 列表——改

（1）li[索引] = ‘被修改的内容’

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']

li[0]= 'ns' #将索引为0的位置改为‘ns’

print(li) #['ns', 'cdc', [1, 5, 2], 'eht', '辛辰']

（2）li[切片]：= ‘被修改的内容’（迭代式：分成最小的元素，一个一个添加）

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']

li[0:2] = 'yjhpl' #将索引0-2替换为yjphl,切片之后迭代处理

print(li) #['y', 'j', 'h', 'p', 'l', [1, 5, 2], 'eht', '辛辰']

li[0:3] = [[1,2,3],'ff','nng']print(li) #[[1, 2, 3], 'ff', 'nng', 'eht', '辛辰']

4. 列表——查

（1）从头到尾 ：for循环

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']for i inli:print(i)

（2）某一个：索引

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']print(li[1]) #cdc

（3）一段：切片

li = ['xcsd', 'cdc', [1, 5, 2], 'eht', '辛辰']print(li[0:2]) #['xcsd', 'cdc']

5. 列表——嵌套

li = ['xcsd', 'cdc', ['alex','egon',88], 'eht', 88,'辛辰','💗沉沉']print(li[5][1]) #辰

li[0] = li[0].capitalize() #把列表中第一个元素的首字母大写

print(li) #['Xcsd', 'cdc', ['alex', 'egon', 88], 'eht', 88, '辛辰', '💗沉沉']

print(li[5].replace('辰','chen')) #辛chen

li[2][0] = li[2][0].upper() #把列表中第三个元素列表的第一个元素变为大写

print(li) #['Xcsd', 'cdc', ['ALEX', 'egon', 88], 'eht', 88, '辛chen', '💗沉沉']

6. 列表——循环打印

#索引默认从零开始

li = ['alex','taibai','wusir','egon']for i inli:print(li.index(i),i)print('-------------------------------------')#指定索引从100开始

for index,i in enumerate(li,100):print(index,i)

运行结果：

二、元祖

1. 元祖

元祖：只读列表，只能查询；儿子不能改，孙子是列表则可以改

只有一个元素，不加逗号，是原数据类型；否则是元祖类型

tu1 = (1)

tu2= (1,)print(tu1,type(tu1)) #1

print(tu2,type(tu2)) #(1,)

tu3= ([1])

tu4= ([1],)print(tu3,type(tu3)) #[1]

print(tu4,type(tu4)) #([1],)

2. 元组的基本操作

tu = (1,2,3,'alex',[2,3,4,'xxcc'],'egon')print(tu[2]) #3

print(tu[0:4]) #(1, 2, 3, 'alex')

for i intu:print(i) #循环打印元祖

tu[4][3] = tu[4][3].upper() #把xxcc改为大写

print(tu) #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC'], 'egon')

tu[4].append('sb') #在xcxc后面增加sb

print(tu) #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC', 'sb'], 'egon')

tu[4].insert(4,'bs') #在元组的索引为4的元素列表的索引为4的地方添加bs

print(tu) #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC', 'bs', 'sb'], 'egon')

tu[4].extend('xc') #在元组的索引为4的元素列表中迭代增加xc

print(tu) #(1, 2, 3, 'alex', [2, 3, 4, 'XXCC', 'sb', 'bs', 'x', 'c'], 'egon')

3. 其他常用操作

（1）split:字符串转换成列表 str--->list

s = 'xcsd_cdc_eht_辛辰'

print(s.split('_')) #['xcsd', 'cdc', 'eht', '辛辰']

s1 = 'xc sdc dc eht辛 辰'

print(s1.split(' ')) #['xc', 'sdc', 'dc', 'eht辛', '辰']

（2）join:列表转换成字符串 list--->str

join(可迭代对象iterable) split

可迭代对象iterable：list,str,元祖

li = ['xcsd', 'cdc', 'eht', '辛辰']

s= ''.join(li)print(s) #xcsdcdceht辛辰

s1 = '_'.join(li)print(s1) #xcsd_cdc_eht_辛辰

（3）range：顾头不顾尾——相当于有序的数字列表(可以反向，加步长)

for i in range(2,6):print(i)for i in range(3): #从0开始，0可省略

print(i)for i in range(1,10,2): #起始，截至，步长

print(i)for i in range(10,0,-2): #倒着打印输出

print(i)#笔试题：成功运行，不输出任何结果，不报错

for i in range(0,10,-1):print(i)

应用实例：

#Q&A:循环打印，列表里遇到列表也需要循环打印

li = [1,2,3,5,'alex',[2,3,4,5,'taibai'],'afds']for i inli:if type(i) ==list:for n ini:print(n)else:print(i)

运行结果：

三、字典

1. 字典

（1）数据类型划分：

可变(不可哈希)数据类型 : list,dict,set,

不可变(可哈希)数据类型 : 元祖,bool,int,str,

（2）dict

key（键）必须是不可变数据类型，可哈希

value（值）任意数据类型

（3）dict 优点：二分查找去查询

存储大量的关系型数据

（4）特点：<=3.5版本无序，3.6以后都是有序

2. 增

（1）dic['键'] = 值

dic1 = {'age':18,'name':'xc','sex':'female'}

dic1['height'] = 165

print(dic1) #没有键值对，增加--{'age': 18, 'name': 'xc', 'sex': 'female', 'height': 165}

dic1['age'] = 21

print(dic1) #有键值对，则修改--{'age': 21, 'name': 'xc', 'sex': 'female', 'height': 165}

（2）setdefault

dic1 = {'age':18,'name':'xc','sex':'female'}

dic1.setdefault('weight',120)print(dic1) #没有键值对，增加--{'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}

dic1.setdefault('name','aa')print(dic1) #有键值对，不做任何操作--{'age': 18, 'name': 'xc', 'sex': 'female', 'weight': 120}

3. 删

删除优先使用pop(有返回值，要删除的内容不存在时不报错)，而不是del

(1) pop

dic1 = {'age':18,'name':'xc','sex':'female'}print(dic1.pop('age')) #有age直接删除---有返回值，按键删除

print(dic1) #18 {'name': 'xc', 'sex': 'female'}

print(dic1.pop('erge','没有此键/None')) #没有erge----可设置返回值：没有此键/None

print(dic1) #没有此键/None {'name': 'xc', 'sex': 'female'}

(2) popitem

dic1 = {'age':18,'name':'xc','sex':'female'}print(dic1.popitem()) #('sex', 'female')

#随机删除：有返回值-----返回元祖：删除的键值

(3) clear

dic1 = {'age':18,'name':'xc','sex':'female'}

dic1.clear()#清空元祖

print(dic1) #{}

(4) del

dic1 = {'age':18,'name':'xc','sex':'female'}del dic1['name'] #有，则删除#del dic1['name1'] #没有，则报错

print(dic1) #{'age': 18, 'sex': 'female'}

应用实例：

#dict:删除键中有k的键和值

dic= {'k1':'v1','k2':'v2','a3':'v3'}#（1）

dic1 ={}for i indic:if 'k' not ini:

dic1.setdefault(i,dic[i])print(dic1)

dic=dic1print(dic)#（2）

l =[]for i indic:if 'k' ini:

l.append(i)print(l)for k inl:deldic[k]print(dic)

运行结果：

4. 改

dic = {'age':18,'name':'xc','sex':'female'}

dic2= {'name':'alex','weight':'168'}

dic2.update(dic)#有则更新覆盖，没有则增加

print(dic) #{'age': 18, 'name': 'xc', 'sex': 'female'}

print(dic2) #{'name': 'xc', 'weight': '168', 'age': 18, 'sex': 'female'}

5. 查------得到键值，首选get

dic1 = {'age':18,'name':'xc','sex':'female'}print(dic1.keys(),type(dic1.keys())) #键

print(dic1.values()) #值

print(dic1.items()) #元祖[(‘键’，值),(‘键’，值),(‘键’，值)]

#得到键值，首选get

print(dic1['name']) #有则打印#print(dic1['name1']) #没有则报错

print(dic1.get('name')) #有name直接输出---有返回值

print(dic1.get('name1','没有此键')) #没有name1----可设置返回值：没有此键/None

for i indic1:print(i) #循环打印键(默认为键)

for i indic1.keys():print(i) #循环打印键

for i indic1.values():print(i) #循环打印值

for i indic1.items():print(i) #循环打印键值对

for k,v indic1.items():print(k,v) #打印键和值

6. 字典的嵌套

dic ={'name':['alex','wusir','xinchen'],'py9':{'time':'1213','study_fee':19800,'addr':'CBD',

},'age':21}

dic['age'] = 56 #找到age，再更新为56

print(dic)

dic['name'].append('rt') #找到name，在添加名字

print(dic)

dic['name'][1] = dic['name'][1].upper() #找到name，再把wusir变为大写

print(dic)

dic['py9']['female'] = 6 #找到元祖，增加键值对female:6

print(dic)

应用实例：

#输入一串字符，遇到字母，转换为‘_’,并打印输出

info = input('请输入：')for i ininfo:ifi.isalpha():

info= info.replace(i,'_')print(info)

运行结果：

四、集合

1. 集合

集合：可变的数据类型，里面的元素必须是不可变的数据类型

无序----每次运行结果都不一定一样

不重复----列表去重：先转换为集合，再转换成列表即可

set1 = set({1,2,3})print(set1) #{1, 2, 3}

set2 = {1,2,3,[2,3],{'name':'xc'}} #列表是可变的（不可哈希），所以出错

print(set2) #TypeError: unhashable type: 'list'

2. 基本操作

（1）增

set1 = {'alex','wusir','ritian','egon','barry'}#(1)add #因为集合是无序的，所以每次运行结果不一定一样，增加的位置也不一定一样

set1.add('nvshen') #{'ritian', 'nvshen', 'egon', 'wusir', 'alex', 'barry'}

print(set1)#(2)update

set1.update('xc') #迭代添加，依然是无序的

print(set1) #{'egon', 'x', 'wusir', 'nvshen', 'c', 'alex', 'ritian', 'barry'}

（2）删

set1 = {'alex','wusir','ritian','egon','barry'}#（1）pop--随机删除

print(set1.pop()) #egon：有返回值，返回本次删除的内容

print(set1) #{'barry', 'alex', 'wusir', 'ritian'}#（2）remove——指定元素删除

set1.remove('alex')print(set1) #{'egon', 'wusir', 'barry', 'ritian'}#（3）clear--清空

set1.clear()print(set1) #空集合：set()#（4）del

del set1 #删除之后集合不存在，报错

print(set1) #NameError: name 'set1' is not defined

（3）不能改

无序；

集合中的元素是不可变数据类型

（4）查

set1 = {'alex','wusir','ritian','egon','barry'}for i inset1:print(i)

运行结果：

（5）集合之间的操作

set1 = {1,2,3,4,5}

set2= {4,5,6,7,8}#交集

print(set1 & set2) #(1) {4, 5}

print(set1.intersection(set2)) #(2) {4, 5}

#并集

print(set1 | set2) #(1) {1, 2, 3, 4, 5, 6, 7, 8}

print(set1.union(set2)) #(2) {1, 2, 3, 4, 5, 6, 7, 8}

#反交集--除交集以外的其他元素

print(set1 ^ set2) #(1) {1, 2, 3, 6, 7, 8}

print(set1.symmetric_difference(set2)) #(2) {1, 2, 3, 6, 7, 8}

#差集--前者独有的

print(set1 - set2) #(1) {1, 2, 3}

print(set1.difference(set2)) #(2) {1, 2, 3}

print(set2 - set1) #(1) {8, 6, 7}

print(set2.difference(set1)) #(2) {8, 6, 7}

#子集与超集

set3 = {1,2,3,4,5}

set4= {1,2,3,4,5,6,7,8}print('------ set3是set4的子集 ------')print(set3 < set4) #True

print(set3.issubset(set4)) #True

print('------ set4是set3的超集 ------')print(set4 > set3) #True

print(set4.issuperset(set3)) #True

（6）frozenset

#将set(可变数据类型)转换为不可变数据类型（只读）

s1 = set('nvshen')print(s1,type(s1)) #{'s', 'h', 'n', 'v', 'e'}

s = frozenset('nvshen')print(s,type(s)) #frozenset({'h', 'n', 's', 'v', 'e'})

for i ins:print(i) #可以循环打印(只读)，但不能增加修改删除

五、公共方法

（1）排序

a. 正向排序：sort()

li = [1,5,4,2,6,7,3]

li.sort()print(li) #[1, 2, 3, 4, 5, 6, 7]

b. 倒序排序：li.sort(reverse = True).()

li = [1,5,4,2,6,7,3]

li.sort(reverse=True)print(li) #[7, 6, 5, 4, 3, 2, 1]

c. 反转：li.reverse()

li = [1,5,4,2,6,7,3]

li.reverse()print(li) #[3, 7, 6, 2, 4, 5, 1]

d. 补充：字符串列表排序——根据字符串的第一个字符对应的ASCII码排序

li = ['ojhy','asa','cvd','hdk']

li.sort()print(li) #['asa', 'cvd', 'hdk', 'ojhy']

（2） count() 数元素出现的次数

li = ['xcsd', 'cdc', '辛辰',[1, 5, 2], 'eht', '辛辰']

num= li.count('辛辰')print(num) #2：'辛辰'出现2次

（3）len() 计算列表的长度

li = ['xcsd', 'cdc', '辛辰',[1, 5, 2], 'eht', '辛辰']

l=len(li)print(l) #6:列表长度为6

（4）li.index('元素') 查看索引

li = ['xcsd', 'cdc', '辛辰',[1, 5, 2], 'eht', '辛辰']print(li.index('eht')) #4:'eht'的索引为4元祖