Python--day06（深浅拷贝、元组、字典、集合）

1.  深浅拷贝

1.1  值拷贝

s1直接将ls中存放的地址拿过来
s1内部的值发生任何变化，s2都会随之变化

s1 = ['1','2','3','a']s2 = s1print(id(s1),id(s2))   #   1986703930376 1986703930376s1[2] = 'b'print(id(s1),id(s2))   #   1986703930376 1986703930376

1.2  浅拷贝

s2 = s1.copy()

新开辟列表空间，但列表中的地址都是直接从ls列表中拿来
s1内部的可变类型值发生改变，ls2会随之变化

s1 = ['1','2','3','a',['1','2']]s2 = s1.copy()s1[4][0] = 4print(s1,id(s1))   #  ['1', '2', '3', 'a', [4, '2']] 2143274411208print(s2,id(s2))   #  ['1', '2', '3', 'a', [4, '2']] 2143275228424

1.3  深拷贝

新开辟列表空间，s1列表中的不可变类型的地址直接拿过来，但是可变类型的地址一定重新开辟空间

from copy import deepcopys1 = ['1','2','3','a',['1','2']]s2 = deepcopy(s1)s1[4][0] = 4print(s1)    #  ['1', '2', '3', 'a', [4, '2']]print(s2)    #  ['1', '2', '3', 'a', ['1', '2']]

2.  元组类型

元组：可以理解为不可变的列表
1.值可以为任意类型
2.可以存放多个值 - 可以进行成员运算
3.可以存放重复的值 - 可以计算成员出现的次数
4.有序存储 - 可以通过索引取值，可以切片

2.1  元组的常用操作

2.1.1  索引取值

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

2.1.2  运算(拼接)

t1 = ('1','2','3','a')t2 = (1,2,3)print(t1 + t2)   #  ('1', '2', '3', 'a', 1, 2, 3)

2.1.3  长度

t1 = ('1','2','3','a')print(len(t1))     #   4

2.1.4  切片

t1 = ('1','2','3','a')print(t1[::-1])    #    ('a', '3', '2', '1')

2.1.5  成员运算

t1 = ('1','2','3','a')print('c' in t1)   #   False

2.1.6  for循环

t1 = ('1','2','3','a')for k in t1:    print(k)

3.  字典类型

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

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

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

3.1  字典的操作（增删改查）

3.1.1 增

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

3.1.2 改

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

3.1.3 查

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

3.1.1 删

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

3.2  字典的其他方法

3.2.1  更新:

dic = {'a':1,'b':2,'c':3}d = {'a':5,'d':10}dic.update(d)print(dic)    #    {'a': 5, 'b': 2, 'c': 3, 'd': 10}

3.2.2  带默认值的新增: 新增key，key已有，啥事不干，没有添加key，值就是第二个参数

dic = {'a':1,'b':2,'c':3}dic.setdefault('x')print(dic)    #    {'a': 1, 'b': 2, 'c': 3, 'x': None}dic.setdefault('y',100)print(dic)    #    {'a': 1, 'b': 2, 'c': 3, 'x': None, 'y': 100}

3.2.3  字典的循环

1.直接循环，就是循环得到keydic = {'a':1,'b':2,'c':3}for k in dic:    print(k,end=' ')    #    a b c 

2.循环keys

dic = {'a':1,'b':2,'c':3}for k in dic.keys():    print(k,end=' ')      #    a b c 

3.循环values

dic = {'a':1,'b':2,'c':3}print(dic.values())     #    dict_values([1, 2, 3])for k in dic.values():    print(k,end=' ')    #    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)])a, b = (1, 2)print(a, b)               #    1 2for res in dic.items():    print(res,end=' ')    #    ('a', 1) ('b', 2) ('c', 3) 

重点：

dic = {'a':1,'b':2,'c':3}for k,v in dic.items():    print(k,v)    # a 1    b 2     c 3  

4.  集合类型

4.1  概念：

概念：
1.set为可变类型 - 可增可删
2.set为去重存储 - set中不能存放重复数据
3.set为无序存储 - 不能索引取值
4.set为单列容器 - 没有取值的key
总结：set不能取值

4.2  集合的增删

4.2.1  增

s = {'1','2','3','a','b','c'}s.add('d')s.add('1')print(s)     #    {'b', '3', '2', 'c', 'd', '1', 'a'}

s = {'1','2','3','a','b','c'}s.update({'q','w','e'})print(s)     #    {'a', '2', 'q', '1', '3', 'c', 'w', 'e', 'b'}

4.2.1  删

s = {'1','2','3','a','b','c'}s.remove('1')print(s)    #    {'3', '2', 'a', 'b', 'c'}s.clear()print(s)    #    set()

4.3  集合的运算

交集：两个都有 &

s1 = {'1','2','3','a'}s2 = {'a','b','c','1','2'}print(s1 & s2)                #    {'a', '1', '2'}print(s1.intersection(s2))    #    {'a', '2', '1'}

合集：两个的合体 |

s1 = {'1','2','3','a'}  s2 = {'a','b','c','1','2'}print(s1 | s2)         #    {'1', '2', 'b', 'a', 'c', '3'}print(s1.union(s2))    #    {'1', '2', 'b', 'a', 'c', '3'}

对称交集：抛出共有的办法的合体 ^

s1 = {'1','2','3','a'}s2 = {'a','b','c','1','2'}print(s1 ^ s2)                      #    {'c', '3', 'b'}print(s1.symmetric_difference(s2))  #    {'c', '3', 'b'}

差集：独有的

s1 = {'1','2','3','a'}s2 = {'a','b','c','1','2'}print(s1 - s2)               #  {'3'}print(s1.difference(s2))     #  {'3'}

比较：前提一定是包含关系

s1 = {'1','2','3','a'}s2 = {'a','b','c','1','2'}s3 = {'1','2'}print(s1 > s2)   # Falseprint(s1 > s3)   # True