Python基础 之列表、字典、元组、集合

基础数据类型汇总

一、列表（list）

例如：删除索引为奇数的元素

lis=[11,22,33,44,55]

#第一种：
for i in range(len(lis)):
    if i%2==1:
        del lis[i]
print(lis)

#第二种
li=[]
for i in lis:
    if lis.index(i)%2==0:
        li.append(i)
lis=li
print(lis)

#第三种:
for i in range(len(lis)-1,-1,-1):
    if i%2==1:
        del lis[i]
print(lis)

#第四种：当然 最简单了
lis=lis[0::2]
print(lis)

注意：在循环一个列表时，最好不要删除列表中的元素，这样会使索引发生改变，从而报错。

二、字典（dict）

dic=dict.fromkeys([1,2,3],"二哥")
print(dic)       #{1: '二哥', 2: '二哥', 3: '二哥'}

1.同一个列表

dic=dict.fromkeys([1,2,3],[])
print(dic)       #{1: [], 2: [], 3: []}

dic[1].append("二哥")
print(dic)       #{1: ['二哥'], 2: ['二哥'], 3: ['二哥']}

2.删除键为“k”开头的键值对

dic={"k1":"v1","k2":"v2","a1":"v3"}
#第一种：
dic1={}
for i in dic:
    if "k" not in i:
        dic1.setdefault(i,dic[i])
dic=dic1
print(dic)

#第二种：
l=[]
for i in dic:
    if "k" in i:
        l.append(i)
for i in l:
    del dic[i]
print(dic)

注意：字典、列表删除时不能循环键值对

三、元组（tuple）

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

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

注意：如果元组里面只有一个元素 ，且不加逗号，则此元素是啥类型就是啥类型；

         如果有其他元素或只有一个逗号，就是元组。

四、集合

集合操作

特点：1)集合为可变的数据类型，但集合元素必须是不可变的数据类型。

           2)无序

           3不重复

1、创建集合

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

2、增

1）add

set1={"alex","wusir","ritain","egon","barry",}

set1.add("女神")
print((set1))          #{'wusir', 'barry', 'ritain', 'egon', 'alex', '女神'}

2)update：迭代添加

set1={"alex","wusir","ritain","egon","barry",}

set1.update("abc")
print(set1)        #{'egon', 'barry', 'c', 'b', 'alex', 'a', 'wusir', 'ritain'}

3、删除

1）、pop(随机删除,有返回值)

set1={"alex","wusir","ritain","egon","barry",}

set1.pop()       #随机删除（有返回值）
print(set1)       #{'egon', 'barry', 'alex', 'ritain'}

2)remove(按元素)

set1={"alex","wusir","ritain","egon","barry",}

set1.remove("alex")   #按元素
print(set1)       {'ritain', 'egon', 'wusir', 'barry'}

3）clear(清空集合)

set1={"alex","wusir","ritain","egon","barry",}

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

4）del(删除字典)

set1={"alex","wusir","ritain","egon","barry",}

del set1      #删除集合
print(set1)     #报错

不能改：无序、元素为不可变数据类型

4、查

for循环

set1={"alex","wusir","ritain","egon","barry",}

for i in set1:
    print(i)

5、交集（&  或者 intersection）

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

6、并集（| 或者 union）

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

7、反交集（^ 或者 symmetric_difference）

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

8、差集（- 或者 difference）

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

9、子集与超集

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

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同，都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同，都是说明set2是set1超集。

10、5，frozenset不可变集合，让集合变成不可变类型。

s = frozenset('barry')
print(s,type(s))  # frozenset({'a', 'y', 'b', 'r'}) <class 'frozenset'>

深浅copy

1、赋值运算

l1 = [1,2,3,['barry','alex']]
l2 = l1

l1[0] = 111
print(l1)  # [111, 2, 3, ['barry', 'alex']]
print(l2)  # [111, 2, 3, ['barry', 'alex']]

l1[3][0] = 'wusir'
print(l1)  # [111, 2, 3, ['wusir', 'alex']]
print(l2)  # [111, 2, 3, ['wusir', 'alex']]

注意：对于赋值运算来说，l1与l2指向的是同一个内存地址，所以他们是完全一样的。

2、浅拷贝copy

l2 = l1.copy()
print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048
l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896
 
l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016
print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

注意：对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

3，深拷贝deepcopy

import copy
l1 = [1,2,3,['barry','alex']]
l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 222, 3, ['wusir', 'alex']] 2915377167240
print(l2,id(l2[3]))  # [1, 2, 3, ['barry', 'alex']] 2915377167304

注意：对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。

枚举

放可迭代对象，自动匹配索引，默认从0开始。

li=["alex","taibai","wusir","egon"]
for i in enumerate(li):
    print(i)
    
# (0, 'alex')
# (1, 'taibai')
# (2, 'wusir')
# (3, 'egon')

li=["alex","taibai","wusir","egon"]
for index,i in enumerate(li):   #默认从0开始
    print(index,i)          

# 0 alex
# 1 taibai
# 2 wusir
# 3 egon

li=["alex","taibai","wusir","egon"]
for index,i in enumerate(li,1):  #可设置索引从1开始
    print(index,i)
    
# 1 alex
# 2 taibai
# 3 wusir
# 4 egon