基本数据类型补充，深浅copy

#str

s='     '   #只能是以至少一个空格组成的字符串（全空格）

print(s.isspace())

#tuple

当元组只有一个元素组成，并没有","，则该元素是什么数据类型，整体就是什么数据类型

tu = (1)

tu1 = (1,)

print(tu,type(tu))

print(tu1,type(tu1))

#list

# l1 = [111,222,333,444,555] 将索引为奇数位的元素删除

#  方法一:

l1 = [111,222,333,444,555]

l2 = []

for i in range(len(l1)):

    if i % 2 == 0:

        l2.append(l1[i])

l1 = l2

print(l1)

# 方法二:

l1 = [111,222,333,444,555,666,777]

del l1[1::2]

print(l1)

l1 = [111,222,333,444,555]

for i in range(len(l1)-1,0,-1):

    if i % 2 == 1:

        del l1[i]

print(l1)

在循环一个列表时，如果要是删除某些或者某类元素，容易出错

#fromkeys()

dic = dict.fromkeys('abc','alex')

print(dic)

dic1 = dict.fromkeys([1,2,3],[])

print(dic1)

dic1[1].append('alex')

print(dic1)

输出结果为：

字典

字典查询时用的是二分查找，速度快。

不可变的数据类型：可哈希　　　　可变的数据类型：不可哈希

循环删除字典中含有k的键值对：

dic = {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}

l1 = []

for i in dic:

    if 'k' in i :

        l1.append(i)

for k in l1:

    del dic[k]

print(dic)

在循环一个字典时，如果删除某些键值对，可能会报错，需要利用列表来删除

数据类型之间的转化：

str-->list 　　 split

list-->str 　　 “”.join

tuple-->list 　　 list(tuple)

list-->tuple 　 tuple(list)

dict专属类型:与list转换

dic = {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}

print(list(dic.keys()))

print(list(dic.values()))

print(list(dic.items()))

深浅copy

1，先看赋值运算。

l1 = [1,2,3,['barry','alex']]

l2 = l1

l1[0] = 111

print(l1)  # [111, 2, 3, ['barry', 'alex']]

print(l2)  # [111, 2, 3, ['barry', 'alex']]

l1[3][0] = 'wusir'

print(l1)  # [111, 2, 3, ['wusir', 'alex']]

print(l2)  # [111, 2, 3, ['wusir', 'alex']]

对于赋值运算来说，l1与l2指向的是同一个内存地址，所以他们是完全一样的。

2，浅拷贝copy。

l1 = [1,2,3,['barry','alex']]

l2 = l1.copy()

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048

l1[1] = 222

print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896

l1[3][0] = 'wusir'

print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

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

3，深拷贝deepcopy。

import copy

l1 = [1,2,3,['barry','alex']]

l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2915377167816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[1] = 222

print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2915377167816

print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[3][0] = 'wusir'

print(l1,id(l1[3]))  # [1, 222, 3, ['wusir', 'alex']] 2915377167240

print(l2,id(l2[3]))  # [1, 2, 3, ['barry', 'alex']] 2915377167304

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

巴特西