一、元组转换 

数字

tu = (1)tu1 = (1,)print(tu,type(tu))print(tu1,type(tu1))

执行输出：

1 <class 'int'>

(1,) <class 'tuple'>

 

 字符串

tu = ('lao')tu1 = ('lao',)print(tu,type(tu))print(tu1,type(tu1))

执行输出：

lao <class 'str'>

('lao',) <class 'tuple'>

 

列表

tu = ([1,2,3])tu1 = ([1,2,3],)print(tu,type(tu))print(tu1,type(tu1))

执行输出：

[1, 2, 3] <class 'list'>

([1, 2, 3],) <class 'tuple'>

 

总结：

对于元组：如果只有一个元素，并且没有逗号，此元素数据类型不会改变。

如果结尾有逗号，就是元组类型

 

元组转换为列表

tu = (1,2,3)li = list(tu)print(li)

执行输出：

[1, 2, 3]

 

列表转换为元组

tu = [1,2,3]li = tuple(tu)print(li)

执行输出：

(1, 2, 3)

 

字符串直接转换为元组是没有方法的。

除非把字符串转换为列表，再转换为元组

 

数字，字符串，列表，元祖，字典对应的布尔值的False分别是什么？

数字0

字符串 ''

列表 []

元组 ()

字典 {}

 

二、列表的坑

将索引为奇数的元素删除

li = ['laonanhai','python','alex','wusir','egon','ritian','nvsheng']

正常写法

li = ['laonanhai','python','alex','laonanhai','egon','ritian','nvsheng']for i in li:    if li.index(i) % 2 == 1:        li.pop(li.index(i))print(li)

执行输出：

['laonanhai', 'alex', 'laonanhai', 'ritian', 'nvsheng']

输出的结果，并不是我想要的，怎么办呢？有3种写法

第一种，使用切片，最简单的

li = ['laonanhai','python','alex','laonanhai','egon','ritian','nvsheng']del li[1::2]print(li)

执行输出:

['laonanhai', 'alex', 'egon', 'nvsheng']

 

第二种，使用新列表覆盖

li = ['laonanhai','python','alex','laonanhai','egon','ritian','nvsheng']li_1 = []for i in range(len(li)):    if i % 2 == 0:        li_1.append(li[i])li = li_1print(li)

执行输出，效果同上

 

第三种，倒序删除。

li = ['laonanhai','python','alex','laonanhai','egon','ritian','nvsheng']for i in range(len(li)-1,-1,-1):    if i % 2 == 1:        del li[i]print(li)

执行输出，效果同上

倒着删除，不会影响前面的，只影响后面的。

 

总结：

对于list,在循环一个列表时，最好不要进行删除的动作(一旦删除,索引会随之改变),容易出错。

   

 三、字典的坑

字典 fromkeys() 方法用于创建一个新的字典，并以可迭代对象中的元素分别作为字典中的键，且所有键对应同一个值，默认为None

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

执行输出：

{'c': 'alex', 'b': 'alex', 'a': 'alex'}

 

使用列表创建一个新字典

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

执行输出：

{1: [], 2: [], 3: []}

 

字典的第一个坑

给列表1添加一个元素

dic = dict.fromkeys([1,2,3],[])dic[1].append('北京')print(dic)

执行输出：

{1: ['北京'], 2: ['北京'], 3: ['北京']}

 

坑就来了，这3个列表，在内存中对应的是同一个列表

 

字典的第二个坑

将字典中含有K元素的键，对应的键值对删除

dic = {'k1':'value1','k2':'value2','name':'wusir'}

正常思路的写法：

dic = {'k1':'value1','k2':'value2','name':'wusir'}for i in dic.keys():    if 'k' in i:        dic.pop(i)        print(dic)

执行报错：

RuntimeError: dictionary changed size during iteration

意思就是，在循环字典过程中，不允许改变字典

换一种思路，在字典中最加

dic = {'k1':'value1','k2':'value2','name':'wusir'}count = 0for i in dic:    dic[i+str(count)] = dic[i]    count +=1print(dic)

执行报错，效果同上。

 

这题应该这么做，先将含有k的键值对，添加到列表

然后循环列表，删除字典的Key

dic = {'k1':'value1','k2':'value2','name':'wusir'}li = []for i in dic:    if 'k' in i:        li.append(i)for i in li:    dic.pop(i)print(dic)

执行输出：

{'name': 'wusir'}

 

总结：

在循环列表或者字典的时候，千万不要做添加或者删除操作。

 

四、集合

集合是没有索引，是无序的。

数据类型：

不重复，无序，它里面的元素是可哈希的。它本身是不可哈希，他不能作为字典的key

作用：

1.去重

2.数据关系测试

 

列表去重

列表的去重，直接转换为集合，就可以了

li = [11,11,22,22,33,33,33,44]li = list(set(li))print(li)

执行输出：

[33, 11, 44, 22]

 

集合常用操作

增加

add() 添加一个元素

set1 = {'wusir','ritian'}set1.add('女神')print(set1)

执行输出：

{'wusir', '女神', 'ritian'}

 

update() 迭代增加

set1 = {'wusir','ritian'}set1.update('abc')print(set1)

执行输出：

{'wusir', 'c', 'ritian', 'b', 'a'}

 

删

remove() 删除一个元素

set1 = {'wusir','ritian'}set1.remove('wusir')print(set1)

执行输出：

{'ritian'}

 

pop() 随机删除

pop() 是有返回值的

set1 = {'wusir','ritian'}print(set1.pop())print(set1)

执行输出：

{'ritian'}

 

clear() 清空集合

set1 = {'wusir','ritian'}set1.clear()print(set1)

执行输出：

set()

 

del 删除集合

set1 = {'wusir','ritian'}del set1

　　

集合没有改的方法

查

查只能for循环

set1 = {'wusir','ritian'}for i in set1:    print(i)

执行输出：

ritian

wusir

 

五、集合关系测试

交集( &或者intersection)

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

执行输出：

{4, 5}

{4, 5}

 

并集( |或union)

set1 = {1,2,3,4,5}set2 = {4,5,6,7,8}print(set1 | set2)print(set1.union(set2))

执行输出：

{1, 2, 3, 4, 5, 6, 7, 8}

{1, 2, 3, 4, 5, 6, 7, 8}

 

反交集( ^或 symmetric_difference)

和交集，取反的结果，也就是说，删除相同的，保留不同的。

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

执行输出：

{1, 2, 3, 6, 7, 8}

{1, 2, 3, 6, 7, 8}

 

差集( - 或difference)

set1 = {1,2,3,4,5}set2 = {4,5,6,7,8}print(set1 - set2)print(set1.difference(set2))

执行输出：

{1, 2, 3}

{1, 2, 3}

 

子集(issubset)

判断一个集合是否被另外一个集合包含

set1 = {1,2,3}set2 = {1,2,3,4,5,6}print(set1.issubset(set2))

执行输出：

True

 

超集(issuperset)

判断一个集合是否包含另外一个集合

set1 = {1,2,3}set2 = {1,2,3,4,5,6}print(set2.issuperset(set1))

执行输出：

True

 

集合关系测试，记符合就可以了，英文字母太长了，不好记。

 

frozenset()将集合转换为可哈希的类型，可以作为字典的key

set1 = {'barry','wusir'}set2 = frozenset(set1)print(set2)

执行输出：

frozenset({'barry', 'wusir'})

 

六、深浅copy

li_1 = [1,2,3]li_2 = li_1li_2.append(456)print(li_1)print(li_2)

执行输出：

[1, 2, 3, 456]

[1, 2, 3, 456]

执行结果是一样的。

对于赋值运算，指向的是同一个内存地址。字典，列表，集合都一样

 

copy

li_1 = [1,2,3]li_2 = li_1.copy()li_2.append(111)print(li_1)print(li_2)

执行输出：

[1, 2, 3]

[1, 2, 3, 111]

 

copy不是指向一个，在内存中开辟了一个内存空间

li_1 = [1,2,3]li_2 = li_1.copy()li_2.append(111)print(id(li_1))print(id(li_2))

执行输出：

2204788806984

2204788808776

发现，内存地址是不一样的。

 

2层列表copy

li_1 = [1,2,[1,2,3],4]li_2 = li_1.copy()#内部列表添加一个值li_1[2].append(666)print(li_1)print(li_2)

执行输出：

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

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

 

为什么呢？因为内部的列表内存地址是独立的一个，一旦修改，其他引用的地方，也会生效。

对于浅copy来说，第一层创建的新的内存地址

而从第二层开始，指向的都是同一个内存地址

copy一般很少用，面试会考到。

 

深copy必须要导入一个模块copy

import copyli_1 = [1,2,[1,2,3],4]li_2 = copy.deepcopy(li_1)#内部列表添加一个值li_1[2].append(666)print(li_1)print(li_2)

执行输出：

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

[1, 2, [1, 2, 3], 4]

 

深copy，每一层，是完全用新的内存地址

浅copy，第一层是新的，从第二层开始，共用一个内存地址

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

 

面试题：

下面的例子，l2是深copy还是浅copy

l1 = [1,2,3,[22,33]]l2 = l1[:]l1[3].append(666)print(l2)

执行输出：

[1, 2, 3, [22, 33, 666]]

 

对于切片来说，它是属于浅copy

 

七、编码补充

s = 'alex's1 = s.encode('utf-8') #unicode --> utf-8 编码s2 = s.encode('gbk') #unicode --> gbk 解码#utf-8转成unicodes3 = s1.decode('utf-8')print(s3)

执行输出：

alex

 

utf-8和gbk不能直接互相转化

必须通过unicode才可以。

s = '老男孩's1 = s.encode('gbk') #unicode转换为gbks2 = s1.decode('gbk') #gbk转换为unicodes2.encode('utf-8') #unicode转换为utf-8print(s2)

执行输出：

老男孩