关于python:05Python列表元祖字典集合操作大全建议收藏

数据结构基本上就是——它们是能够解决一些 数据 的 构造。或者说，它们是用来存储一组相干数据的。

在 Python 中有四种内建的数据结构——列表、元组和字典，汇合。咱们将会学习如何应用它们，以及它们如何使编程变得简略

一、列表 list

是解决一组有序我的项目的数据结构，即你能够在一个列表中存储一个 序列 的我的项目。假想你有一个购物列表，下面记录着你要买的货色，你就容易了解列表了。只不过在你的购物表上，可能每样货色都单独占有一行，

而在 Python 中，你在每个我的项目之间用逗号宰割。列表中的我的项目应该包含在方括号中，这样 Python 就晓得你是在指明一个列表。

一旦你创立了一个列表，你能够增加、删除或是搜寻列表中的我的项目。因为你能够减少或删除我的项目，咱们说列表是 可变的 数据类型，即这种类型是能够被扭转的

# 购物清单
shoplist = ['苹果', '芒果', '胡萝卜', '香蕉']

基本操作

print ('我有', len(shoplist),'个商品在我的购物清单.')
print ('它们是:'), # 提醒
​
for item in shoplist:
    print(item)
print ('我还买了大米.')
​
shoplist.append('大米')
print ('当初我的购物清单是', shoplist)
# ['苹果', '芒果', '胡萝卜', '香蕉','大米']

基本操作——增

append 追加

li = ['苹果', '芒果', '胡萝卜', '香蕉']
li.append('大米')
print(li)
# ['苹果', '芒果', '胡萝卜', '香蕉','大米']
​
li.append(1)
# ['苹果', '芒果', '胡萝卜', '香蕉','大米', 1]
​
print(li.append('hello'))   
#None：无返回值，li.append()只是一个办法、动作
​
print(li)   
# ['苹果', '芒果', '胡萝卜', '香蕉','大米', 1 , 'hello']

insert 插入

li = ['苹果', '芒果', '胡萝卜', '香蕉']
li.insert(3,'草莓')
​
print(li)   
# ['苹果', '芒果', '胡萝卜', '草莓', '香蕉']

extend 追加到开端

li = ['苹果', '芒果', '胡萝卜', '香蕉']
li.extend('cc')
print(li)
# ['苹果', '芒果', '胡萝卜', '香蕉', 'c', 'c']
​
li.extend([1,2,3])
print(li)
# ['苹果', '芒果', '胡萝卜', '香蕉', 'c', 'c', 123]
​
li.extend(123) #报错：数字不能迭代
print(li)   
#TypeError: 'int' object is not iterable

利用实例：

间断输出员工姓名，输出 Q / q 退出并打印列表

li = []
while True:
    username = input("请输出要增加的员工姓名：")
    if username.strip().upper() == 'Q':
        break
    li.append(username)
    print(li)
print(li)

运行后果：

]

列表——删

remove：依照元素删除

li = ['苹果', '芒果', '胡萝卜', '香蕉']
li.remove('芒果')
print(li)  
#  ['苹果', '胡萝卜', '香蕉']

pop：依照索引删除——有返回值

li = ['苹果', '芒果', '胡萝卜', '香蕉']
name = li.pop(1)  #有返回值
print(name,li)
# 芒果 ['苹果', '胡萝卜', '香蕉']
​
name = li.pop()  #不写索引则默认删除最初一个
print(name,li)
# 香蕉 ['苹果', '胡萝卜']

clear：清空

li = ['苹果', '芒果', '胡萝卜', '香蕉']
li.clear()
print(li)
#[]

del：删除

li = ['苹果', '芒果', '胡萝卜', '香蕉']
del li[2:]
print(li)
# ['苹果', '芒果']
​
del li  #删除之后，曾经不存在，打印报错
print(li)
 #NameError: name 'li' is not defined

循环删除

li = [11,22,33,44,55]
for i in range(len(li)):
    print(i)
    del li[0]
    print(li)

列表——改

li[索引] =‘被批改的内容’

li = ['苹果', '芒果', '胡萝卜', '香蕉']
li[0] = '火龙果'  #将索引为 0 的地位改为‘火龙果’print(li)
# ['火龙果', '芒果', '胡萝卜', '香蕉']

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

li = ['苹果', '芒果', '胡萝卜', '香蕉']
li[0:2] = 'abcd' 
# 将索引 0 - 2 替换为 abcd, 切片之后迭代解决
​
print(li)
// ['a', 'b', 'c', 'd', '胡萝卜', '香蕉']
​
li[0:3]=['我','喜爱','吃','水果']
print(li)
// ['我', '喜爱', '吃', '水果', 'd', '胡萝卜', '香蕉'

列表——查

从头到尾：for 循环

li = ['苹果', '芒果', '胡萝卜', '香蕉']
for i in li:
    print(i)

某一个：索引

li = ['苹果', '芒果', '胡萝卜', '香蕉']
print(li[1])    #芒果

一段：切片

li = ['苹果', '芒果', '胡萝卜', '香蕉']
print(li[0:2])    #['苹果', '芒果', '胡萝卜']

列表——嵌套

li = ['苹果', '芒果', '胡萝卜', ['a','b','c'],'香蕉']
print(li[2][1]) #萝
li[3][0].upper() 
#把列表中第四个元素列表的第一个元素变为大写
​
print(li)
# ['苹果', '芒果', '胡萝卜', ['a', 'b', 'c'], '香蕉']

列表——循环打印

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

运行后果：

其余罕用操作

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 曾', '木木']

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_木木

range：顾头不顾尾——相当于有序的数字列表(能够反向，加步长)

for i in range(2,6):
    print(i)

利用实例：

循环打印，列表里遇到列表也须要循环打印

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

运行后果：

二、元祖

元组和列表非常相似，只不过元组和字符串一样是 不可变的 即你不能批改元组。元组通过圆括号中用逗号宰割的我的项目定义。

元组通常用在使语句或用户定义的函数可能平安地采纳一组值的时候，即被应用的元组的值不会扭转

tu1 = (1)
tu2 = (1,)
print(tu1,type(tu1))    #1 <class 'int'>
print(tu2,type(tu2))    #(1,) <class 'tuple'>

tu3 = ([1])
tu4 = ([1],)
print(tu3,type(tu3))    #[1] <class 'list'>
print(tu4,type(tu4))    #([1],) <class 'tuple'>

元组的基本操作

tu = (1,2,3,'alex','egon')
print(tu[2])    #3
print(tu[0:2])  #(1, 2)
for i in tu:
    print(i)    #循环打印元祖

字典

字典相似于你通过联系人名字查找地址和联系人详细情况的地址簿，即，咱们把键（名字）和值（详细情况）分割在一起。留神，键必须是惟一的，就像如果有两个人凑巧同名的话，你无奈找到正确的信息。

留神，你只能应用不可变的对象（比方字符串）来作为字典的键，然而你能够把不可变或可变的对象作为字典的值。

根本说来就是，你应该只应用简略的对象作为键。

键值对在字典中以这样的形式标记：d = {key1 : value1, key2 : value2}。

留神它们的键 / 值对用冒号宰割，而各个对用逗号宰割，所有这些都包含在花括号中

dict
key（键）必须是不可变数据类型，可哈希
value（值）任意数据类型

dict 长处：二分查找去查问
存储大量的关系型数据
特点：<=3.5 版本无序，3.6 当前都是有序

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}

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}

2. 字典—— 删

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

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)

popitem 随机删除

dic1 = {'age':18,'name':'xc','sex':'female'}
print(dic1.popitem())  
#('sex', 'female')
#随机删除：有返回值 ----- 返回元祖：删除的键值

clear 清空

dic1 = {'age':18,'name':'xc','sex':'female'}
dic1.clear()    #清空字典
print(dic1)     #{}

del 删除

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

3. 字典—— 改

update

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'}

4. 字典——查

keys，values，items

dic1 = {'age':18,'name':'xc','sex':'female'}
​
print(dic1.keys(),type(dic1.keys()))    
#键 dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>
​
print(dic1.values())    
#值 dict_values([18, 'xc', 'female'])
​
print(dic1.items())     
#元祖 dict_items([('age', 18), ('name', 'xc'), ('sex', 'female')])

失去键值，首选 get

print(dic1['name'])      #有则打印
#print(dic1['name1'])    #没有则报错
​
print(dic1.get('name'))  
#有 name 间接输入 --- 有返回值
​
print(dic1.get('name1','没有此键'))  
#没有 name1---- 可设置返回值：没有此键 /None

循环输入

for i in dic1:
    print(i)    #循环打印键(默认为键)
for i in dic1.keys():
print(i)    #循环打印键
for i in dic1.values():
print(i)    #循环打印值

5. 字典的嵌套

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 in info:
    if i.isalpha():
        info = info.replace(i,'_')
print(info)

运行后果：

四、汇合

汇合 相似于列表，但每个元素都必须是举世无双且不可变的：

它是无序的

基本操作

print(set1)     
#{1, 2, 3}
​
set2 = {1,2,3,[2,3],{'name':'xc'}}  
#列表是可变的（不可哈希），所以出错
print(set2)     
#TypeError: unhashable type: 'list'

1. 汇合——增

add

set1 = {'alex','wusir','ritian','egon','barry'}
# (1)add    #因为汇合是无序的，所以每次运行后果不肯定一样，减少的地位也不肯定一样
set1.add('nvshen')  
#{'ritian', 'nvshen', 'egon', 'wusir', 'alex', 'barry'}
print(set1)

update

set1.update('xc')   
#迭代增加，仍然是无序的
print(set1) 
#{'egon', 'x', 'wusir', 'nvshen', 'c', 'alex', 'ritian', 'barry'}

2. 汇合——删

set1 = {'alex','wusir','ritian','egon','barry'}

pop– 随机删除

print(set1.pop())   
#egon：有返回值，返回本次删除的内容
​
print(set1)     
#{'barry', 'alex', 'wusir', 'ritian'}

remove——指定元素删除

set1.remove('alex')
print(set1)    
 #{'egon', 'wusir', 'barry', 'ritian'}

clear——清空

set1.clear()
print(set1)     
#空集合：set()

del

del set1        
​
#删除之后汇合不存在，报错
print(set1)    
 #NameError: name 'set1' is not defined

3. 汇合不能改

汇合是无序；

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

4. 汇合——查

set1 = {'alex','wusir','ritian','egon','barry'}
for i in set1:
    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

五、公共办法

排序

正向排序：sort()

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

倒序排序：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]

反转：li.reverse()

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

补充：

字符串列表排序——依据字符串的第一个字符对应的 ASCII 码排序

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

count() 数元素呈现的次数

li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
num = li.count('木木')
​
print(num)  #2：'木木' 呈现 2 次

len() 计算列表的长度

li = ['xcsd', 'cdc', '木木',[1, 5, 2], 'eht', '木木']
l = len(li)
print(l)   #6: 列表长度为 6 

li.index(‘ 元素 ’) 查看索引

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

六. 区别与异同

练习地址：www.520mg.com/it