一、元组转换

数字

tu = (1)

tu1 = (1,)

print(tu,type(tu))

print(tu1,type(tu1))

执行输出：

1

(1,)

字符串

tu = ('lao')

tu1 = ('lao',)

print(tu,type(tu))

print(tu1,type(tu1))

执行输出：

lao

('lao',)

列表

tu = ([1,2,3])

tu1 = ([1,2,3],)

print(tu,type(tu))

print(tu1,type(tu1))

执行输出：

[1, 2, 3]

([1, 2, 3],)

总结：

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

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

元组转换为列表

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_1

print(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 = 0

for i in dic:

dic[i+str(count)] = dic[i]

count +=1

print(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_1

li_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 copy

li_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转成unicode

s3 = s1.decode('utf-8')

print(s3)

执行输出：

alex

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

必须通过unicode才可以。

s = '老男孩'

s1 = s.encode('gbk') #unicode转换为gbk

s2 = s1.decode('gbk') #gbk转换为unicode

s2.encode('utf-8') #unicode转换为utf-8

print(s2)

执行输出：

老男孩