Python Day 7 基础数据类型（基础数据类型补充知识点,集合，数据类型转换，集合，深浅copy）

Python Day 7

数据类型的补充

1、元组补充

元组里面如果只有一个元素且没有逗号，则该数据的数据类型与里面的元素相同。（int,list,dict同理）

tu1 = ('laonanhai') 
tu2 = ('laonanhai',)

print(tu1, type(tu1))
laonanhai <class 'str'>

print(tu2, type(tu2))
('laonanhai',) <class 'tuple'>

2、列表补充

在循环一个列表时，最好不要改变列表的大小，会影响你的最终结果。可以一次性切片完成，或使用循环时倒着删除

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

方法1：
del l1[1::2]

方法2：
for index in range(len(l1)-1, -1, -1):
    if index % 2 == 1:
        del l1[index]
print(l1)

3、字典补充

在循环dict中，最好不要改变dict的大小，会影响结果或者报错。

可以设置两个字典进行操作。

数据类型的转换

str ---> list split
list --> str join

tuple ---> list
tu1 = (1, 2, 3)
l1 = list(tu1)
print(l1)
tu2 = tuple(l1)
print(tu2)

dic ----> list  list(dic)(列表中的元素只有key)

转布尔值
0, '', [], () {}  ---> bool 都是Fasle

集合 （主要用在去重，和关系测试）

集合是一个可变的数据类型，他是以{}形式存在的，空集合set(),但是它要求它里面的元素是不可变的，集合是无序的，不重复的。

1、去重：

# 列表的去重
l1 = [11, 11, 22, 22, 33, 33, 33, 44]
l2 = list(set(l1))
l2.sort()
print(l2)

2、集合的增删查。

1、增 （两种方法）

　　1.set.add('new')

set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.add('太白')
print(set1)

　　2.set.update('new') 迭代增加

set1.update('abc')
set1.update([111, 222, 333])
print(set1)

2、删（四种方法）

　　1.set.remove('aa')  按元素删除

set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.remove('RiTiAn')
print(set1)

　　2.set.pop()  由于集合无序，删除是随机删除，有返回值，返回值是删除的元素。

set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
print(set1.pop())
print(set1)

　　3.set.clear() 清空集合

set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
set1.clear()
print(set1)

　　4.del set 从内存删除集合

del set1

3、查（一种方法，由于集合是无序的，只能使用循环查找。）

　　1.for循环查。

set1 = {'alex', 'WuSir', 'RiTiAn', 'egon', 'barry'}
for i in set1:
    print(i)

3、集合关系测试

1、交集   （&   set1.intersection(set2) ）

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
#交集
set3 = set1 & set2
set3 = set1.intersection(set2)
print(set3)

2、反交集 （^  set1.symmetric_difference(set2) ）

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
#反交集
set3 = set1 ^ set2
set3 = set1.symmetric_difference(set2)
print(set3)

3、差集 (-  set1.difference(set2) )

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

#差集 (独有的)
set3 = set1 - set2
set3 = set1.difference(set2)
print(set3)

4、并集 (|  set1.union(set2) )

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

#并集 (set1 和set2加起来所有的)
set3 = set1 |set2
set3 = set1.union(set2)
print(set3)

5、子集 (<  set1.issubset(set2))  返回bool值

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}
#子集
print(set1 < set2)

print(set1.issubset(set2))

6、超集（> set1.issuperset）返回bool值

set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5, 6}

#超集
print(set2 > set1)
print(set2.issuperset(set1))

7、冻集合 frozenset  返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

set1 = frozenset({1, 2, 3, 'alex'})
print(set1,type(set1))

深浅copy

1、赋值运算 （对于赋值运算来说，指向的都是同一个内存地址，一变都变。）

l1 = [1, 2, 3]
l2 = l1
l3 = l2
l3.append(666)   #修改任意一个，每一个都改变，赋值运算指向的都是同一个内存地址。
print(l1, l2, l3)

[1, 2, 3, 666] [1, 2, 3, 666] [1, 2, 3, 666]

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

l1 = [11, 22, 33]
l2 = l1.copy()
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))
#浅copy，第一层内存不同
[11, 22, 33, 666] 1881530148296
[11, 22, 33] 1881530277640

=========================
l1 = [11, 22, ['barry', [55, 66]], [11, 22]]
l2 = l1.copy()
l1[2].append('alex')
print(l1,id(l1))
print(l2,id(l2))
#浅copy，第一层改变后内存不同
[11, 22, ['barry', [55, 66], 'alex'], [11, 22]] 1881530323656
[11, 22, ['barry', [55, 66], 'alex'], [11, 22]] 1881530148296

print(l1, id(l1[-1]))
print(l2, id(l2[-1]))
#浅copy，第二层改变后内存相同
[11, 22, ['barry', [55, 66], 'alex'], [11, 22]] 1881530323592
[11, 22, ['barry', [55, 66], 'alex'], [11, 22]] 1881530323592

对于切片来说，是浅copy。

l1 = [1, 2, 3, 4, 5, 6, [11,22]]
l2 = l1[:]
l1.append(666)
print(l1, l2)
#第一层内存改变
[1, 2, 3, 4, 5, 6, [11, 22], 666] [1, 2, 3, 4, 5, 6, [11, 22]]


l1 = [1, 2, 3, 4, 5, 6, [11,22]]
l2 = l1[:]
l1[-1].append(666)
print(l1, l2)
#修改第二层，内存地址不变
[1, 2, 3, 4, 5, 6, [11, 22, 666]] [1, 2, 3, 4, 5, 6, [11, 22, 666]]

3、深copy （深copy 完全独立。） 需要引入模块   import copy

import copy
l1 = [11, 22, 33]
l2 = copy.deepcopy(l1)
l1.append(666)
print(l1, id(l1))
print(l2, id(l2))
#第一层内存地址独立
[11, 22, 33, 666] 2033332295304
[11, 22, 33] 2033332295496

=============
l1 = [11, 22, ['barry']]
l2 = copy.deepcopy(l1)
l1[2].append('alex')
print(l1, id(l1[-1]))
print(l2, id(l2[-1]))
#第二层内存地址独立
[11, 22, ['barry', 'alex']] 2239009560200
[11, 22, ['barry']] 2239009561608