python第六天

时间:2023-03-08 16:14:11

深浅拷贝,元祖,字典 ,集合的定义以及基本操作方法

深浅拷贝

# 值拷贝:应用场景最多
​值拷贝:
先创建一个列表
ls = [1, 'abc', [10]]
再定义 ls1 = ls  此处ls1会直接将ls中在栈区存放的地址拿过来,也就是列表的门牌号,
所以在 ls 当列表内部的元素发生变化,ls1都会随之变化,因为值拷贝指挥把存储列表的地址拿过来,并不能把值的地址拿过来 ​浅拷贝:
再定义 ls2 = ls.copy()  使用copy()元素,它会早内存中开辟新列表的空间,但列表中的值地址都是直接从ls列表中拿过来的
所以 ls 内部的不可改变类型的元素地址不会改变,而可变类型元素发生改变,ls2中存放的值会随之变化
​深拷贝:
再定义 ls3 = deepcopy(ls)  使用deepcopy()元素, 它会在内存中开辟新的列表空间,ls列表中的不可变类型的地址直接拿过来(优化机制),而可变类型的元素地址会重新开辟新的空间,
当 ls 内部的所有类型的值发生改变,ls3都不会随之变化

元组类型

'''
元组:可以理解为不可变的列表
# 1.值可以为任意类型
# 2.可以存放多个值 - 可以进行成员运算
# 3.可以存放重复的值 - 可以计算成员出现的次数
# 4.有序存储 - 可以通过索引取值,可以切片
'''
# 常用操作
# 1.索引取值
tuple = (1,2,3,4,5)
print(tuple[1],type(tuple[1]))
print(tuple[-3],type(tuple[-3]))
# 2.运算(拼接)
tuple = (1,2,3,4,5)
tuple1 = (5,7,8,9,10)
print(tuple + tuple1)

# 3.长度
tuple = (1,2,3,4,5)
print(len(tuple))
# 4.切片
tuple = (1,2,3,4,5)
print(tuple[1:5:1])
)

# 5.成员运算
tuple = (1,2,3,4,5)
print(1 in tuple) # 判断 1 是不是在 tuple 中,返回bool
print(1 not in tuple) # 判断 1 是不是不在tuple中 返回bool

# 6.for循环
tuple = (1,2,3,4,5)
for i in tuple:
print(i,end = '')
print()


# 方法
tuple = (1,2,3,4,5)
print(tuple.count(5)) # 对象5在tuple元组中出现的次数

tuple = (1,2,3,4,5)
print(tuple.index(3,1,len(tuple))) # 对象3在元组内 从1号位至末尾,第一次出现的索引,此处返还 2

字典类型

字典相关概念

# 容器(集合):存放多个值的变量
# 单列容器(系统中的单列容器很多):list | tuple
# 双列容器(map):只有dict,存放数据 成对出现,dict存放数据采用 key-value键值对方式


# 字典中的key可以为什么类型:key必须为不可变类型
#       -- key是取value的唯一依据,key一旦被确定,就需要唯一确定(不能被改变)
# 字典中的value可以为什么类型:value可以为任意类型
#       -- value是用来存放世间所有存在的数据

# key要确保唯一性,不能重复,值可以重复,并且可以被改变 => 字典为可变类型

dic = {'a': 10, 1: 20, True: 30, (): 40}  # 1和True都是1,key具有唯一性,所以只保留最后一次值
print(dic)  # {'a': 10, 1: 30, (): 40}

字典的定义

字典是另一种可变容器模型,且可存储任意类型对象。

字典的每个键值 key=>value 对用冒号 : 分割,每个键值对之间用逗号 , 分割,整个字典包括在花括号 {} 中 ,  英文名称 dict ,格式如下所示:

d = {key1 : value1, key2 : value2 }

不允许同一个key出现两次。创建时如果同一个key被赋值两次,后一个值会被记住,key的命名与变量名的命名一样

而value值它可以为任意类型的值

# 空字典
d1 = {}
d2 = dict()
# 用map映射创建字典
d3 = dict({'a': 1, 'b': 1})
print(d3)
# 用关键字赋值方式
d4 = dict(name='Bob', age=18)  # 参数=左侧的名字就是合法的变量名,都会被转化为字符串形式的key
print(d4)
# 创建有多个key值采用默认值的方式: 默认值不写默认None,也可以自定义
d5 = {}.fromkeys('abc', 0)
print(d5)

字典的操作

dic = {'a': 1, 'b': 2}
print(dic)

# 增: 字典名[key] = 值 => key已存在就是修改值,不存在就是新增值
dic = {'a':1,'b':2,'c':3,'d':4}
print(dic)
dic['e'] = 5 # 直接把需要添加的key放入[]中 等号后面放value
print(dic)
# 改
dic = {'a':1,'b':2,'c':3,'d':4}
print(dic)
dic['d'] = 5 # 此处把 ' d ' 对应的value 改成了 5 ,方法与添加一样
print(dic)
# 查:字典名[key]
dic = {'a':1,'b':2,'c':3,'d':4}
print(dic)
print(dic['d']) 此处查询key 'd',返回’d'的value, 它只能查找已有的key,没有会崩溃(报错)

有默认值的查询:如果字典中有所查询的key,那么他会取出对应value,如果没有找到key,他会报错,可以用get()来获取,如果没有找到,他会返还默认值,默认值可以自定义
dic = {'a':1,'b':2,'c':3,}
print(dic.get('d', '未找到')) 此处使用get(),此处并没有'd'这个key,他会返回一个None,如果设定了默认值就返回默认值,此处默认值为 '未找到'

# 删
dic = {'a':3,'b':4,'c':5}
print(dic.clear()) # 清空整个字典,返回值为None
# pop(k)删除指定key的value并返还删除的value
dic = {'a':3,'b':4,'c':5}
print(dic.pop('a')) #此处删除了 'a' ,打印它会返回删除的value
print(dic) # 再次打印不会出现key 'a' 了
# dic = dic.pop('a')
print(dic)
# 从dic末尾删除,返还(key, value)形成的元组
dic = {'a':3,'b':4,'c':5}
dic = dic.popitem() #使用 popitem() 从末尾删除 key和value
print(dic) # 打印后返回(key,value)形成的元祖


# 其他方法
# 更新字典: a有值覆盖,c没被新操作,带下来,b为新增,增加并赋值
dic = {'a': 1, 'c': 2}
d = {'a': 10, 'b': 20}
dic.update(d)
print(dic)  # {'a': 10, 'c': 2, 'b': 20}

# 带默认值的新增: 新增key,key已有,啥事不干,没有添加key,值就是第二个参数
setdefault() 方法和 get()方法 类似, 如果key不已经存在于字典中,将会添加key并将value设为默认值。
dic = {'a':3,'b':4,'c':5}
print(dic.setdefault('d','未找到'))


# 字典的循环
# 1.直接循环,就是循环得到key
dic = {'a':1,'b':2,'c':3}
for i in dic: #直接for 循环
print(i) # 此处输出结果为 a,b,c 得到 key
# 2.循环keys
dic = {'a':1,'b':2,'c':3}
print(dic.keys()) # 输出结果为 dict_keys(['a', 'b', 'c']) dic = {'a':1,'b':2,'c':3}
for i in dic.keys(): #for 循环keys()
  print(i) # 输出结果为 a,b,c
# 3.循环values
dic = {'a':1,'b':2,'c':3}
print(dic.values()) # 输出的结果为dict_values([1, 2, 3])
dic = {'a':1,'b':2,'c':3}
for i in dic.values():
print(i) # 输出结果为 1,2,3
# 同时循环key和value (key, value)
dic = {'a':1,'b':2,'c':3}
print(dic.items()) #此处输出结果为dict_items([('a', 1), ('b', 2), ('c', 3)])
dic = {'a':1,'b':2,'c':3}
for i in dic.items():
  print(i) # 此处输出结果为(’a',1)('b',2)('c',3)
# 重点****
dic = {'a':1,'b':2,'c':3}
for k,v in dic.items(): # key ,和value一起循环
print(k,v) # 此处输出结果为 a 1 | b 2 | c 3


# 解压赋值
# a, _, _, b = (1, 2, 3, 4)

集合类型

定义空集合不能用 {} ,因为用来标示空字典的,我们定义空集合可以用set()
可以在括号里加(),从内部括号中传值。
s = set() # 空集合
s = set(('a','b','c'))
print(s, type(s))
如果 {} 中不存value,只存一个元素,# a = {'a','b','c'} 那么他就是一个合集,如果放入key + value那就是字典
# 概念:
# 1.set为可变类型 - 可增可删
# 2.set为去重存储 - set中不能存放重复数据
# 3.set为无序存储 - 不能索引取值
# 4.set为单列容器 - 没有取值的key
# 总结:set不能取值

# 增
a = set(('a','b'))
a.add('c')
print(a) # 使用add() 依次可以传入一个参数,无序添加(因为集合本无序) 用它自己和其他元素的并集更新一个集合:
a = set(('a','b'))
a.update('c','d','e','f')  # 直接添加默认只可合并可迭代对象(数字不可迭代)
print(a) # 无序
a = set((1,'b'))
a.update({'c',2}) # 如果需要合并数字,可以在括号中添加可以迭代的括号()[] {},
print(a) # 打印结果是合集 {2,'b','c',1} (也是无序排列)


# 删
a = set((1,'b'))
a = a.pop() # 删除并返回任意集合元素。如果集合为空,则引发KeyError(报错) pop()不接受人和参数设定
print(a)
 
a = set((1,'b'))
a.remove(1,) # remove()可以删除指定的值,但是每次只能指定一个值。而且指定的值必须在集合内,否则报错
print(a)
 
a = set((1,'b'))
a.clear() #从该集合中删除所有元素,返回空集合
print(a)



# set运算
# 交集:两个都有 &
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py & lx) # 算两个集合的交集,返还所求的相同的元素,此处为egon
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py.intersection(lx)) # intersection 的功能等同与 & 号


# 合集:两个的合体
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py | lx) # 将两个集合的并集作为一个新集合返回。(即任何一个集合中的所有元素。)
print(py.uinon(lx)) # union 效果等同与 | 号

# 对称交集:抛出共有的办法的合体 ^
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py ^ lx) # 将两个集合的对称 差分,转化为一个新的集合,(即恰好位于其中一个集合中的所有元素。)
# 理论上可以理解为转换为一个新集合,存放两个集合所有的值,但是因为集合去重效果,会把相同的值,只存放一个
print(py.symmetric_difference(lx))  # symmetric_difference 效果等同与 ^ 号


# 差集:独有的
py = {'a', 'b', 'c', 'egon'}
lx = {'x', 'y', 'z', 'egon'}
print(py - lx) # 返回 py 中与 lx不重复的值
print(py.difference(lx)) #difference 效果等同与 - 号
print(lx - py) # 返回 lx 中与 lx 不重复的值
print(lx.difference(py)) #difference 效果等同与 - 号

# 比较:前提一定是包含关系
子类与父类的比较
s1 = {'1', '2'}
s2 = {'2'} # s2 中的元素必须在s1中才可比较
print(s1 < s2) # 此处是False,因为s1 要大于s2