基本数据类型补充，深浅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来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。