Python之路Day7

今日大纲
1.基础数据类型的补充
2.基础数据类型set
    2.1 集合的创建
    2.2 集合的增删查
    2.3 集合的交并差运算
3.深浅拷贝
    3.1 浅拷贝
    3.2 深拷贝

1.基础数据类型的补充
1.1 元组

tu1 = ("北京")
tu2 = ("北京",)
print(tu1,type(tu1))
print(tu2,type(tu2))
执行结果：
北京 <class 'str'>
('北京',) <class 'tuple'>

tu1 = ([11,22,33])
tu2 = ([11,22,33],)
print(tu1,type(tu1))
print(tu2,type(tu2))
执行结果：
[11, 22, 33] <class 'list'>
([11, 22, 33],) <class 'tuple'>

    当（）中，只有一个数据，且没有逗号时，外表像元组，但数据类型不是元组，而是（）中这个数据的数据类型。
1.2 列表

l1 = [111, 222, 333, 444, 555, ]
索引为奇数对应的所有元素全部删除。

方法一：
l1 = [111, 222, 333, 444, 555, ]
del l1[1::2]
print(l1)
方法二：
l1 = [111, 222, 333, 444, 555, 666, 777, 888, ]
for i in range(len(l1)-1,-1,-1): #倒着打印，不会影响每次i在原列表中的索引
    if i % 2 == 1:
        del l1[i]
print(l1)
方法三
l1 = [111, 222, 333, 444, 555, 666, 777, 888, 999 ]
l2 = [111, 222, 333, 444, 555, 666, 777, 888, 999 ]
for i in range(len(l2)):
    if i % 2 == 1:
        l1.remove(l2[i])
print(l1)

错误示例
l1 = [111, 222, 333, 444, 555, 666, 777, 888, 999 ]
for i in range(len(l1)):
    if i % 2 == 1:
        del li[i]
print(l1)

    对于for循环遍历列表时，不可在循环过程中，改变列表的大小及原数据的位置，否则会报错或者得不到想要的结果。

1.3 字典
(1)dict.fromkeys()

dic = dict.fromkeys("abc",[11,22,33])  #将第一个位置的数据迭代成最小元素，作为字典的key,第二个值作为共用value
print(dic)  #结果： {'a': [11, 22, 33], 'b': [11, 22, 33], 'c': [11, 22, 33]}
dic = dict.fromkeys([666,777,888],[11,22,33])
print(dic)  #{666: [11, 22, 33], 777: [11, 22, 33], 888: [11, 22, 33]}

dic = dict.fromkeys("abc",[11,22,33])
print(dic)  #结果： {'a': [11, 22, 33], 'b': [11, 22, 33], 'c': [11, 22, 33]}
dic["a"].append(44) #由于内存中dic的key，共用同一个值，对其中一个key对应的列表添加值，其他key也会添加该值
print(dic)

(2)改变字典的长度
在循环dict中，最好不要改变dict的大小，会影响结果或者报错。

dic = {'k1': 'v1', 'k2': 'v2','k3': 'v3','name': 'alex'}
将key中有"k"的键值对删除

错误示例
dic = {'k1': 'v1', 'k2': 'v2','k3': 'v3','name': 'alex'}
for key in dic:
    if "k" in key:
        del dic[key]    #del 改变了dict的大小
print(dic)

正确示例
dic = {'k1': 'v1', 'k2': 'v2','k3': 'v3','name': 'alex'}
l1 = list(dic.keys())
for i in l1:
    if "k" in i:
        del dic[i]
print(dic)

1.4 数据类型之间的转换

str ---> list  split

list ---> str  join

tuple ---> list
tu = (11, 22, 33,)
li = list(tu)
print(li)

list ---> tuple
li = [11,22,33]
tu = tuple(li)
print(tu)

dic ---> list
dic = {"k1":11,"k2":22,"k3":33}
li = list(dic) #将字典的key 存储在列表中
print(li)
print(list(dic.keys())) #将字典的key 存储在列表中
print(list(dic.values()))#将字典的value存储在列表中
print(list(dic.items()))#以(key,value) 元组形式存储在列表中 [('k1', 11), ('k2', 22), ('k3', 33)]

---> bool  0 , "", [], (), {}, ---> False
s = [0, 0 , 0]
print(bool(s)) #True

2.集合
  集合是一个可变的数据类型，他是以{}形式存在的，空集合set(),
  但是它要求它里面的元素是不可变的，集合是无序的，不重复的。
  作用：1，去重。
        2，关系测试。
2.1 创建集合

set1 = set() #创建空集合
set2 = {11, 22, 33}
print(set1,type(set1))  #set() <class 'set'>
print(set2,type(set2)) #{33, 11, 22} <class 'set'>

集合是一个可变类型，但集合中的元素必须是不可变类型：字符串，数字，布尔值，元组
set3 = {11, "abc", (11, 22, 33,), True}
print(set3)

集合是无序的，可以自动去重
set4 = {11, 22, 22, 22, 11, 33}
print(set4) #{33, 11, 22}

列表的去重
先将列表转换为集合(列表中只能是不可变类型)，然后再将转换后的集合，转为列表即可
li = [11, 11, 11, 33, 33, "abc", "abc"]
set5 = set(li)
print(set5)
li1 = list(set5)
print(li1)

2.2 集合的增 删 查 （无索引，无法修改）
增

add
set6 = {"aa", "bb", "cc", "dd", "ee"}
set6.add("ff")
print(set6)
update 将数据迭代着添加到集合中去
set6 = {"aa", "bb", "cc", "dd", "ee"}
set6.update("fgh")
print(set6) #{'aa', 'f', 'dd', 'bb', 'cc', 'ee', 'h', 'g'}

set6 = {"aa", "bb", "cc", "dd", "ee"}
set6.update([11,22,33])
print(set6) #{33, 'dd', 'cc', 11, 'ee', 'aa', 'bb', 22}

删

remove 按照值删除
set6 = {"aa", "bb", "cc", "dd", "ee"}
set6.remove("bb")
print(set6)
pop 随机删除，有返回值
set6 = {"aa", "bb", "cc", "dd", "ee"}
set6_pop = set6.pop()
print(set6_pop)
print(set6)
clear 清空集合
set6 = {"aa", "bb", "cc", "dd", "ee"}
set6.clear()
print(set6) #set()
del 删除整个集合
set6 = {"aa", "bb", "cc", "dd", "ee"}
del set6
print(set6) #报错

查

set6 = {"aa", "bb", "cc", "dd", "ee"}
for i in set6:
    print(i)

2.3 集合的交集 并集 差集 反交集 子集 超集

交集 & intersection
set1 = {11, 22, 33, 44, 55}
set2 = {44, 55, 66, 77, 88}
print(set1 & set2) #{44, 55}
print(set1.intersection(set2))

并集 |  union
set1 = {11, 22, 33, 44, 55}
set2 = {44, 55, 66, 77, 88}
print(set1 | set2) #{33, 66, 11, 44, 77, 22, 55, 88}
print(set1.union(set2))

差集 - difference
set1 = {11, 22, 33, 44, 55}
set2 = {44, 55, 66, 77, 88}
print(set1 - set2) #set1 独有的 {33, 11, 22}
print(set1.difference(set2))
print(set2 - set1) #set2 独有的 {88, 66, 77}
print(set2.difference(set1))

反交集 ^ symmetric_difference 与交集相反的集合
set1 = {11, 22, 33, 44, 55}
set2 = {44, 55, 66, 77, 88}
print(set1 ^ set2) #{33, 66, 22, 88, 11, 77}
print(set1.symmetric_difference(set2))

子集 < issubset
set1 = {11, 22, 33, 44, 55}
set2 = {11, 22, 33}
print(set2 < set1) #True set2 是set1的子集
print(set2.issubset(set1))

超集 > issuperset
set1 = {11, 22, 33, 44, 55}
set2 = {11, 22, 33}
print(set1 > set2) #True set1 是set2的超集
print(set1.issuperset(set2))

由于集合是可变类型，不可作为字典的key，所以选择用frozenset冻结集合，该数据类型是不可变类型
set1 = frozenset({1, 2, 3, 'alex'})
print(set1,type(set1)) #frozenset({1, 2, 3, 'alex'}) <class 'frozenset'>

3.深浅拷贝
3.1 赋值运算

l1 = [1, 2, 3]
l2 = l1
l2.append(666)
print(l1, l2) #[11, 22, 33, 44] [11, 22, 33, 44]
对于赋值运算，内存中l1 l2 共用一个内存地址，对l2 进行数据添加，那么纸箱内存地址的l1自然也跟着变化

3.2 浅拷贝

l1 = [11, 22, 33]
l2 = l1.copy()
l1.append(666)
print(l1,id(l1)) #[11, 22, 33, 666] 6454344
print(l2,id(l2)) #[11, 22, 33] 6454984

l1 = [11, 22, 33, [111, 222, 333]]
l2 = l1.copy()
l1[-1].append(666)
print(l1,id(l1),id(l1[-1])) #[11, 22, 33, [111, 222, 333, 666]] 4161224 4160584
print(l2,id(l2),id(l2[-1])) #[11, 22, 33, [111, 222, 333, 666]] 38806152 4160584

对于浅copy来说，对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始
，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

3.3 深拷贝

import copy
l1 = [11, 22, 33]
l2 = copy.deepcopy(l1)
l1.append(666)
print(l1,id(l1)) #[11, 22, 33, 666] 41009608
print(l2,id(l2)) #[11, 22, 33] 40799752

import copy
l1 = [11, 22, 33,[111, 222, 333]]
l2 = copy.deepcopy(l1)
l1[-1].append(666)
print(l1,id(l1[-1])) #[11, 22, 33, [111, 222, 333, 666]] 42844552
print(l2,id(l2[-1])) #[11, 22, 33, [111, 222, 333]] 42844872

深copy 完全独立。

3.4 对于列表，即使两个值是一样的，但是列表没有小数据池的概念，所以各自有各自的内存地址，且各级独立，类似深拷贝

l1 = [11, 22, 33]
l2 = [11, 22, 33]
l1.append(666)
print(l1,id(l1)) #[11, 22, 33, 666] 6323272
print(l2,id(l2)) #[11, 22, 33] 6323912

l1 = [11, 22, 33, [111, 222]]
l2 = [11, 22, 33, [111, 222]]
l1[-1].append(666)
print(l1,id(l1),id(l1[-1])) #[11, 22, 33, [111, 222, 666]] 34373320 34372680
print(l2,id(l2),id(l2[-1])) #[11, 22, 33, [111, 222]] 39694984 39658056

3.5 对于切片来说，这是浅copy。

l1 = [11, 22, 33]
l2 = l1[::]
l1.append(666)
print(l1,id(l1)) #[11, 22, 33, 666] 37977160
print(l2,id(l2)) #[11, 22, 33] 37977800


l1 = [11, 22, 33, [111, 222]]
l2 = l1[:]
l1[-1].append(666)
print(l1,id(l1),id(l1[-1])) #[11, 22, 33, [111, 222, 666]] 34438856 34438216
print(l2,id(l2),id(l2[-1])) #[11, 22, 33, [111, 222, 666]] 41755272 34438216