目录
元祖tuple
作用
相当于一个只可取不能更改的列表, 在创建时就被写死了.
定义
()内用逗号隔开多个元素(可以为任意数据类型)
tup = (1, 2, 3)
tup = tuple((1, 2, 3))
# 注意: 如果定义只有一个元素的元祖, 必须要加逗号, 否则为字符串
tup = (1,) # 元祖
tup = (1) # 字符串使用方法
tup = (1, 2, 3)
# 1. 索引取值
print(tup[0])
# 2. 索引切片
print(tup[0:2])
# 3. for循环
for i in tup:
print(i)
# 4. 成员运算
print(0 in tup)
# 5. len长度
print(len(tup))
# 6. index获取元素索引
print(tup.index(1))
# 7. count计数
print(tup.count(2))集合(set)
作用
进行集合之间关系运算/去重/无序
定义方式
{}内用逗号隔开多个元素(不可变数据类型)
s = {1, 2, 3}
s = set({1, 2, 3})使用方法
s1 = {1, 2, 3}
s2 = {2, 3, 4}
# 1. 交集
print(s1 & s2) # {2, 3}
# 2. 并集
print(s1 | s2) # {1, 2, 3, 4}
# 3. 补集
print(s1 ^ s2) # {1, 4}
# 4. 差集
print(s1 - s2) # {1}s = {1, 2, 3}
# 1. add添加元素
s.add(4)
print(s)
# 2. remove移除元素, 没有会报错
s.remove(1)
print(s)
# 3. discard丢弃元素, 没有不会报错
s.discard(1)
print(s)
# 4. pop随机删除一个元素
s.pop()
print(s)集合是无序/可变数据类型
字典内置方法
dic = {'a': 1, 'b': 2, 'c': 3}
# 1. 按key取值/按key修改值/按key增加值
print(dic['a']) # 1
dic['a'] = 0
print(dic) # {'a': 0, 'b': 2, 'c': 3}
dic['d'] = 4
print(dic) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 2. 成员运算(比较的是key)
print('a' in dic) # True
print('e' not in dic) # True
# 3. for循环(对key循环)
for i in dic:
print(i) # a b c
# 4. len长度
print(len(dic)) # 3
# 5. del删除
del dic['a']
print(dic) # {'b': 2, 'c': 3}
# 6. keys()/values()/items() -- 返回列表
print(dic.keys()) # 所有的key
print(dic.values()) # 所有的值
print(dic.items()) # 所有的键值对
# 7. get() 取值
print(dic.get('a', 0)) # 找到了就返会a在字典中对应的值, 没找到就返回None, 如果给定了0, 没找到就返回0
# 8. update() 扩展字典
dic1 = {'d': 4}
dic.update(dic1)
print(dic) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 9. fromkeys() 按key创建字典
dic = dict.fromkeys(['name','age','gender'], None)
print(dic) # {'name': None, 'age': None, 'gneder': None}
# 10. setdefault() 有则不变,无则增加
dic.setdefault('a', 2)
print(dic) # {'a': 1, 'b': 2, 'c': 3}
dic.setdefault('d', 4)
print(dic) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}深浅拷贝
拷贝/浅拷贝/深拷贝都是针对可变数据类型而言的.
拷贝
如果lis2 是lis1的拷贝对象, 则1内部的元素变化, 则lis2内部的元素也跟着改变.
lis1 = ['a', 'b', 'c', ['d','e','f']]
lis2 = lis1
lis1[-1].append('g')
lis1.append('h')
print(lis1) # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
print(lis2) # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
浅拷贝
如果lis2是lis1的浅拷贝对象, 则l1内的不可变元素发生了变化, lis2不变; 如果lis1内的可变可变元素发生了改变, 则lis2会跟着改变.
import copy
lis1 = ['a', 'b', 'c', ['d','e','f']]
lis2 = copy.copy(lis1)
lis1[-1].append('g')
lis1.append('h')
print(lis1) # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
print(lis2) # ['a', 'b', 'c', ['d', 'e', 'f', 'g']]深拷贝
如果lis2是lis1的深拷贝对象, lis2永远不会因为lis1的变化而变化.
import copy
lis1 = ['a', 'b', 'c', ['d','e','f']]
lis2 = copy.deepcopy(lis1)
lis1[-1].append('g')
lis1.append('h')
print(lis1) # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
print(lis2) # ['a', 'b', 'c', ['d', 'e', 'f']]