Day 07

元祖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']]

转载于:https://www.cnblogs.com/bigb/p/11529013.html