计算机二级python_2_python组合数据类型

列表

列表(list)是有序的，列表中的值可以是任何数据类型，列表的元素有索引。

列表对象用方括号包围，逗号分隔

[1,2,'a',4]

访问元素

访问元素,使用索引

lis = [1, 2, 'a']
print(lis[0])    # 1
print(lis[1])    # 2
print(lis[2])    # a

添加元素

append()

lis = [1, 2, 'a']
lis.append(3)
print(lis)        # [1, 2, 'a', 3]

删除元素

remove()

根据元素删除

lis = [1, 2, 'a']
lis.remove('a')
print(lis)    # [1, 2]

pop()

删除列表末尾的元素

lis = [1, 2, 'a']

lis.pop()    # 删除末尾的元素 'a'
print(lis)    # [1, 2]

lis.pop()    # 删除末尾的元素 2
print(lis)    # [1]

del

根据索引删除，或删除整个列表

lis = [1, 2, 'a']

del lis[1]  # 删除索引为1的元素
print(lis)

del lis     # 删除整个列表
print(lis)  # NameError: name 'lis' is not defined

其他列表操作

count()

返回某个元素在列表中出现的次数

lis = [1, 2, 3, 1]
print(lis.count(1))  # 2
print(lis.count(2))  # 1

extend()

向列表末尾追加另一个列表的所有元素

lis1 = [1, 2, 3]
lis2 = [3, 2, 1]

lis1.extend(lis2)

print(lis1) # [1, 2, 3, 3, 2, 1]

index()

返回列表中第一次出现的某个元素的索引

lis = ['a', 'b', 'c', 'a', 'c', 'b']
print(lis.index('a'))   # 0
print(lis.index('b'))   # 1

reverse()

反转列表元素的排列顺序

lis = [1, 2, 3, 'a', 4]

lis.reverse()
print(lis) # [4, 'a', 3, 2, 1]

sort()

永久将列表升序，列表元素需要是数字类型

lis = [3, 2, 1, 4, 2.5]

lis.sort()
print(lis)  # [1, 2, 2.5, 3, 4]

sorted()

临时将列表升序，sorted()不是列表属性

lis = [3, 2, 1, 4, 2.5]

sorted(lis)
print(lis)      # [3, 2, 1, 4, 2.5]

print(sorted(lis))  # [1, 2, 2.5, 3, 4]

列表切片

根据索引切分列表，和字符串切片一样

lis[开始位置: 截止位置: 步长],       

根据索引 左闭右开  [开始索引, 截止索引) ，

步长为正，取到截止索引 -1的位置

步长为负，取到截止索引 +1 的位置

lis = ['a','b','c','d','e','f']

print(lis[0:5]) # ['a', 'b', 'c', 'd', 'e']

print(lis[0:6]) # ['a', 'b', 'c', 'd', 'e', 'f']

print(lis[5:0:-1]) # ['f', 'e', 'd', 'c', 'b']

列表检查

lis = ['a','b','c','d','e','f']

print('a' in lis)   # True
print(1 in lis)     # False

元组

元组(tuple) 用小括号包裹，逗号分隔。

创建元组

用逗号分隔一些数据，就会创建一个元组,创建一个元素的元组，只需要在后面加逗号

k = 'a', 'b'
print(k)   # ('a', 'b')
print(type(k)) # <class 'tuple'>

t = (1,)
print(type(t)) # <class 'tuple'>

s = 'a',
print(type(s)) # <class 'tuple'>

连接、删除元组

元组的元素值不能修改，但是可以对元组进行连接

tup1 = ('a', 'b')
tup2 = ('c', 1)

tup = tup1 + tup2
print(tup) # ('a', 'b', 'c', 1)

元组的元素也不允许删除，只能用del删除整个元组

tup1 = ('a', 'b')
del tup1

内置函数使用

python的一些内置函数,如len()、max()、min()、tuple()等，对元组(tuple)的操作,

tup = (2,4,5,2)
print(len(tup))     # 4
print(max(tup))     # 5
print(min(tup))     # 2

# 将列表转换为元组
lis = ['a', 1, 3]
new = tuple(lis)
print(new)          # ('a', 1, 3)
print(type(new))    #<class 'tuple'>

字典

字典是键值对的无序集合，用花括号{}包裹，冒号分开“键”和“值”，逗号分隔元素

元素获取

字典根据键获取值

dic = {"a":1, 'b':2, 'c':3}
# 获取某个键的值
print(dic['a'])             # 1
print(dic.get('a'))         # 1

# 获取所有键,并存为列表
print(list(dic.keys()))     # ['a', 'b', 'c']

# 获取所有值并存为列表
print(list(dic.values()))   # [1, 2, 3]

# 将字典键值对转为列表
print(list(dic.items()))    # [('a', 1), ('b', 2), ('c', 3)]

更新（修改）字典

dic = {"a": 1, 'b': 2, 'c': 3}

dic['a'] = 11
print(dic)  # {'a': 11, 'b': 2, 'c': 3}

删除键值对

del

dic = {"a": 1, 'b': 2, 'c': 3}

del dic['a']
print(dic)  # {'b': 2, 'c': 3}

遍历字典

遍历 键和值

遍历键

遍历值

其他字典操作

clear()

用于清空字典内容，

copy()

返回一个具有相同键值对的新字典

dic = {"a": 1, 'b': 2, 'c': 3}

dic2 = dic.copy()
print(dic2) # {'a': 1, 'b': 2, 'c': 3}

集合

集合存储的元素无序且不重复。

集合用花括号{}包裹

可以用set()创建，或者直接创建

s1 = {'a', 'b', 'c'}
s2 = set([1,2,'c'])

print(type(s1)) # <class 'set'>
print(type(s2)) # <class 'set'>

访问集合元素使用迭代的方式

s1 = {'a', 'b', 'c'}

for item in s1:
    print(item, end=',')    # a,b,c,

集合运算

集合的运算符	描述
A-B	返回A捏不属于B的集合
A&B	返回属于A且属于B的集合（A∩B)
A^B	返回不是A和B共同元素的集合 (A∪B - A∩B)
A|B	返回A和B的所有元素的集合（A∪B）

集合的方法

方法	描述
A.issubset(B)	A是B的子集，则返回True，否则False
B.issuperset(A)	B是A的超集合，返回True。（即A是B的子集）
A.union(B)	A∪B
A.intersection(B)	A∩B
A.difference(B)	A - B,属于A但不属于B的集合
A.symmetric_difference(B)	A∪B - A∩B
A.copy()	复制集合A，返回新集合

A = {'a', 'b', 'c'}
B = {1, 2, 3, 'a', 'b'}
AC = {'a', 'b'}

# 子集
print(B.issubset(A))  # False
print(AC.issubset(A))  # True

# 父集合
print(A.issuperset(AC))  # True

# 并集
print(A.union(B))  # {1, 2, 3, 'b', 'c', 'a'}

# 交集
print(A.intersection(B))  # {'a', 'b'}

print(A.difference(AC))  #  {'c'}   A-(A∩AC)

print(A.symmetric_difference(B)) # {1, 2, 3, 'c'}   A+B - (A∩B)

N = A.copy()
print(N)    # {'b', 'a', 'c'}