python第六天

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

深浅拷贝

# 值拷贝：应用场景最多
​值拷贝：
先创建一个列表
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