基础数据类型补充、集合、深浅拷贝

基础数据类型补充

元组

如果元组中只有一个数据，且没有逗号，则该 '元组' 与里面的数据的数据类型相同。

>>> tu1 = (2,)
>>> tu2 = ('hello')
>>> tu3 = ([1, 2], )
>>> tu1, type(tu1)
((2,), <class 'tuple'>)
>>> tu2, type(tu2)
('hello', <class 'str'>)
>>> tu3, type(tu3)
(([1, 2],), <class 'tuple'>)

列表

• 列表与列表可以相加

>>> l1 = [1, 2, 3]
>>> l2 = [5, 6, 7]
>>> l1 + l2
[1, 2, 3, 5, 6, 7]

l1 = [11, 22, 33, 44, 55, 66, 77, 88]将列表中索引为奇数的元素，全部删除

• 在循环一个列表时，如果对列表中的某些元素进行删除，

• 那么此元素后面的所有元素就会向前进一位，他们的索引就会发生变化。

  在循环一个列表时，最好不要对此列表进行改变大小（增删）的操作。

1. 方法1：切片+步长删除

>>> l1 = [11, 22, 33, 44, 55, 66, 77, 88]
>>> del l1[1::2]
>>> l1
[11, 33, 55, 77]

1. 方法2：利用另外的空列表

l1 = [11, 22, 33, 44, 55, 66, 77, 88]
l2 = []

for i in range(len(l1)):
    if i % 2 == 0:
        l2.append(l1[i])
print(l2) #[11, 33, 55, 77]
l1 = l2

1. 方法3：倒着删

l1 = [11, 22, 33, 44, 55, 66, 77, 88]
for index in range(len(l1)-1, -1, -1):
    if index % 2 == 1:
        l1.pop(index)
print(l1)

1. 方法4：正着删（因为每次删除一个元素，列表里的元素会自动向前挪动，最前面的那个元素刚好挪动到删除的位置上，下次删除不会再删除它了，所以可以实现隔着删除的功能)

l1 = [11, 22, 33, 44, 55, 66, 77, 88]

for i in l1:
    if i != l1[0]:
        l1.pop(l1.index(i))
print(l1) # [11, 33, 55, 77]

字典

• 在循环一个字典时，千万不要对此列表进行改变大小（增删）的操作。

dict.fromkeys() 注意是dict或是字典对象的方法

>>> dic = dict.fromkeys('abc', 1)
>>> dic
{'a': 1, 'b': 1, 'c': 1}
>>> dic2 = dict.fromkeys([1, 2, 3], 'hello')
>>> dic2
{1: 'hello', 2: 'hello', 3: 'hello'}

>>> dic = {'a':1, 'b':2}
>>> dic.fromkeys('abc', 1)
{'a': 1, 'b': 1, 'c': 1}

• 陷阱 若fromkeys()第二个参数为列表、字典，更改其中一个，其他都会变的。

>>> dic = dict.fromkeys('123', [])

>>> dic['1'].append(666)
>>> dic['2']
[666]
>>> dic['3']
[666]

集合(set)

>>> a = set('abc') # set()里面的参数是必须是可迭代的。
>>> a
{'b', 'a', 'c'}

>>> b = set() # set()表示是空集合，
>>> b
set()
>>> bool(b)  
False

>>> a = set([1,2,3])
>>> a
{1, 2, 3}

增

>>> a = {1, 2, 3}
>>> a.add(4)
>>> a
{1, 2, 3, 4}

>>> a.add('abc') # 只加一个元素
>>> a
{'abc', 1, 2, 3, 4}
>>> a.update('ijk')  # 迭代着加
>>> a
{'abc', 1, 2, 3, 4, 'j', 'i', 'k'}

删

remove()

>>> a
{'abc', 1, 2, 3, 4, 'j', 'i', 'k'}
>>> a.remove('a')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'a'
>>> a.remove('abc')
>>> a
{1, 2, 3, 4, 'j', 'i', 'k'}

pop()

>>> a.pop()
1

clear()

>>> a.clear()
>>> a
set()

del

>>> del a
>>> a
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

关系测试

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

>>> set1 & set2    # 交集
{3, 4}
>>> set1.intersection(set2)
{3, 4}

>>> set1 | set2     # 并集
{1, 2, 3, 4, 5, 6}
>>> set1.union(set2)
{1, 2, 3, 4, 5, 6}

>>> set1 ^ set2     # 反交集
{1, 2, 5, 6}
>>> set1.symmetric_difference(set2)
{1, 2, 5, 6}

>>> set1 - set2     # 差集
{1, 2}

>>> set1 = {1, 2}
>>> set2 = {1, 2, 3, 4}

>>> set1 < set2     # 子集
True
>>> set1.issubset(set2)
True

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

frozenset 不可变的数据类型。 ★★★☆☆

>>> set1 = {1, 2}
>>> set2 = frozenset(set1)
>>> set2
frozenset({1, 2})
>>> {set2: '可以做键'}
{frozenset({1, 2}): '可以做键'}

深浅拷贝

浅拷贝只适用于list, set, dict,用copy()方法，而list的全切lst[:]也是浅拷贝

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

但是由于有代码块和小数据池的作用，第一层的id会都一样，类似两套格局相同的房子都是同一个人的名下。

>>> a = [1,2]
>>> b = a.copy()
>>> c = (1,2)
>>> d = c.copy()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'copy'
>>> e = {'a':1, 'b':2}
>>> f = e.copy()
>>> g = {1, 2, 3}
>>> h = g.copy()
>>> 'asdlf'.copy()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute 'copy'

>>> l1 = [1, 2, 3]
>>> l2 = l1.copy()
>>> id(l1[1])
1780834560
>>> id(l2[1])
1780834560
>>> l1 = [1, 2, 3, 'python']
>>> l2 = l1.copy()
>>> id(l1[-1])
2641351388888
>>> id(l2[-1])
2641351388888

>>> l3 = [[1,2], 3]
>>> l4 = l3.copy()
>>> id(l3[0])
2641351422152
>>> id(l4[0])
2641351422152
>>> l4[0].append(4)
>>> l3
[[1, 2, 4], 3]

对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。

>>> import copy
>>> l3
[[1, 2, 4], 3]
>>> l5 = copy.deepcopy(l3)
>>> l3[0].append(666)
>>> l5
[[1, 2, 4], 3]
>>> l3
[[1, 2, 4, 666], 3]