Python面试100讲（二）列表、元组、字典

最新推荐文章于 2022-10-13 11:44:15 发布

勤勤恳恳的勤勤

最新推荐文章于 2022-10-13 11:44:15 发布

阅读量600

点赞数 2

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/Qinn_ww/article/details/104179243

版权

Python 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1、对列表（元组）去重

（1）在Python中如何定义集合，集合和列表有什么区别

a=[1,2,3]#列表，中括号
print(type(a))

<class ‘list’>

b=(1,2,3)#元组，小括号
print(type(b))

<class ‘tuple’>

c={1,2,2,3}#集合，大括号
print(c)#自动去重
print(type(c))

{1, 2, 3}
<class ‘set’>

区别：
①集合没有重复的元素，列表（元组）可以有重复元素，元组元素只读；
②集合中的元素与顺序无关，而列表（元组）中的元素与顺序有关；
③列表list：[ ]中括号，元组tuple：（）小括号，集合set：{}大括号。

（2）如何去重（列表、元组）：先转换成集合，再转换回来

a=[1,2,2,3]
a_result=list(set(a))
print(a_result)
print(type(a_result))
print(tuple(set(a)))

[1, 2, 3]
<class ‘list’>
(1, 2, 3)

2、集合的并集与交集

（1）如何添加(add)、删除(remove)集合中的元素

x={1,2,3}
x.add(123)
print(x)
x.add("a")
print(x)
x.remove(123)
print(x)

{123, 1, 2, 3}
{1, 2, 3, ‘a’, 123}
{1, 2, 3, ‘a’}

if x.__contains__(444):
    x.remove(444)#检测是否存在
else:
    print('444不存在')

444不存在

删除之前先检测是否存在

（2）集合之间的运算：并、交
并：| 或 .union

x1={1,2,3}
x2={2,3,4}
print(x1|x2)#集合之间的合并
print(x1.union(x2))#集合之间的合并

{1, 2, 3, 4}
{1, 2, 3, 4}

交：&或.intersection

x1={1,2,3}
x2={2,3,4}
print(x1&x2)#集合之间的相交
print(x1.intersection(x2))#集合之间的相交

{2, 3}
{2, 3}

将在x1中有的，x2中也有的删除

print(x1.difference(x2))

{1}

去除x1和x2共有的元素，返回集合并

print(x1^x2)

{1, 4}

3、如何让两个列表首尾相接（保留重复的元素值）

列表连接方式有两种：+和extend;
元组只有一种：+。

a=[1,2]#列表
b=[2,3,4]
c=(1,2,3)#元组
d=(3,4,5)
#法1
print(a+b)
print(c+d)
#法2
a.extend(b)
print(a)
a.extend(c)
print(a)
#法3
x=[*a,*b]
print(x)

[1, 2, 2, 3, 4]
(1, 2, 3, 3, 4, 5)
[1, 2, 2, 3, 4]
[1, 2, 2, 3, 4, 1, 2, 3]
[1, 2, 2, 3, 4, 1, 2, 3, 2, 3, 4]

区别：
① +不会改变参与连接的列表的值，但extend方法可以改变a的值（元组只读，所以不可）；
② +两侧要么都是元组、要么都是列表，不可混合相加但是列表的extend方法可以将一个元组添加列表后。

4、如何打乱列表元素顺序

（1）编写一个函数（不使用Python模块的函数），打乱列表元素的顺序
方法一：随机选择两个数交换位置

a=[1,2,3,4,5,6,7,8,9,0]
import random
def random_list1(a):
    for i in range(0,100):#随机100次
        index1=random.randint(0,len(a)-1)
        index2=random.randint(0,len(a)-1)
        a[index1],a[index2]=a[index2],a[index1]
    return a
b=random_list1(a)
print(b)

[2, 4, 0, 7, 9, 8, 6, 1, 5, 3]

方法2：新建一个列表，每次随机挑选一个元素添加进球，并从原始列表中删除

def random_list2(a):
    a_copy=a.copy()
    result=[]
    count=len(a)
    for i in range(1,count):
        index=random.randint(0,len(a_copy)-1)
        result.append(a_copy[index])
        del a_copy[index]
    return result
a=[1,2,3,4,5,6,7,8,9,0]
b=random_list2(a)
print(b)#不改变原始a值

[5, 4, 0, 6, 3, 1, 9, 2, 8]

（2）如何对列表元素进行随机排列：.shuffle

a=[1,2,3,4,5,6,7,8,9,0]
random.shuffle(a)#改变a值
print(a)

[5, 4, 0, 6, 3, 1, 9, 2, 8]

5、单星* 和双星** 运算符

（1）单星和双星的作用

单星号*
以元组形式导入
可变参数
如果可变参数不是最后一个参数，那么为可变参数后面的形参指定参数值，必须用命名参数

def fun1(param1,*param2,x):#*param2表示可变参数
    print('param1:',param1)
    print('param2:',param2,type(param2))
    print('x:',x)
fun1(1,2,3,4,5,x=6)

param1: 1
param2: (2, 3, 4, 5) <class ‘tuple’>

双星号**
以字典形式导入key和value,key不允许重复

def fun2(param1,**param2):
    print('param1:',param1)
    print('param2:',param2,type(param2))
fun2(1,a=2,c=3,d=4,e=5)

param1: 1
param2: {‘a’: 2, ‘c’: 3, ‘d’: 4, ‘e’: 5} <class ‘dict’>

（2）请描述合并列表和字典的方法有哪些
列表合并（见上）：3种，+，extend，[*a,*b]

a=[1,2]#列表
b=[2,3,4]
f=[*a,*b]
print(f)

[1, 2, 2, 3, 4]

（3）字典合并：

#字典
a={'A':1,'B':2}
b={'C':3,'B':4}
c={**a,**b}
print(c)

{‘A’: 1, ‘B’: 4, ‘C’: 3}

6、快速调换字典中的key和value

（1）如何快速调换字典中的key和value(列表和字典均支持for循环）

d={'a':1,'b':2}
print({v:k for k,v in d.items()})

{1: ‘a’, 2: ‘b’}

（2）如何用循环快速生成一个0到100的列表（[0,1,2…,100]）

a=[i for i in range(101)]
print(a)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]

7、将两个列表或元组合成一个字典：dict、zip（压缩）

a=['a','b']
b=[1,2]
print(dict(zip(a,b)))

{'a': 1, 'b': 2}

循环，迭代（例子代码）；
用于将数据表的字段和记录值合并成一个字典，返回给客户端便于进行其他处理。

8、列表和元组有哪些差异

1、语法差异，列表[],元组（）
2、元组只读，列表可读写（可取）
3、使用tuple函数后，元组还是自身，列表不是自身，会复制一个新列表
4、大小、尺寸不一,元组小（大的内存块）,元素较多时，元组速度更快（zip()压缩）

a=[1,2,3]
b=(1,2,3)
print(a.__sizeof__())
print(b.__sizeof__())

64
48

9、对列表排序

（1）排序列表的方法:.sort,函数sorted()

a=[1,2,4,5,3,8,1,2]
a.sort()#会改变原始列表 
print(a)

b=[2,5,1,6,3,8]
c=sorted(b)#函数sorted()
print(c)

[1, 1, 2, 2, 3, 4, 5, 8]
[1, 2, 3, 5, 6, 8]

区别：
1、sort属于列表，sorted是一个函数；
2、sort改变列表本身，sorted()返回一个排好序的列表副本。

（2）降序排列：reverse=True，反转函数

a.sort(reverse=True)
print(a)

[8, 5, 4, 3, 2, 2, 1, 1]

10、列表、元组与字典

类的Magic方法
operator模块
sort方法和sorted函数的key参数

如果列表元素是对象（类），如何排序??

为类添加__gt__和__lt__方法，可以让该类的实例支持sort方法和sorted函数；
通过改变__gt__和__lt__方法，更改sort方法和sorted函数的reverse参数，可以让列表倒序排列。

class MyClass:
    def __init__(self):
        self.value=0
    def __lt__(self,other):
        return self.value<other.value#法1：升序
    def __gt__(self,other):
        return self.value>other.value#法2：升序
    
my1=MyClass()
my1.value=20

my2=MyClass()
my2.value=10

my3=MyClass()
my3.value=30

a=[my1,my2,my3]
print(a)

a.sort()
print(a[0].value)
print(a[1].value)
print(a[2].value)

import operator
a.sort(key=operator.attrgetter('value'))#法3：升序
b=sorted(a,key=operator.attrgetter('value'))
print(b[0].value)
print(b[1].value)
print(b[2].value)

[<main.MyClass object at 0x0000020337AD5808>, <main.MyClass object at 0x0000020337AD5D48>, <main.MyClass object at 0x0000020337AD5DC8>]
10
20
30
10
20
30

11、del和pop

区别：

del是一个关键字，根据索引删除列表元素，但没有返回值
pop是列表中的一个方法，根据索引弹出列表元素，并返回该元素，同时从列表中删除该元素

a=[1,2,3,4,5]
print(a)
del(a[1])
print(a)

print(a.pop(1))
print(a)

print(a.pop())#默认弹出最后一个元素
print(a)

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

12、用lambda表达式对列表进行排序

lambda表达式的用法：
题目1：如果列表元素是字典类型，如何利用lambda表达式对列表进行升序降序排列？

a=[
    {"name":"bill","age":40},
    {"name":"mike","age":41},
    {"name":"anna","age":36},
]
print(a)
print(sorted(a,key=lambda x:x['age']))#法1

a.sort(key=lambda x:x['age'],reverse=True)#法2，改变原数据
print(a)

[{‘name’: ‘bill’, ‘age’: 40}, {‘name’: ‘mike’, ‘age’: 41}, {‘name’: ‘anna’, ‘age’: 36}]
[{‘name’: ‘anna’, ‘age’: 36}, {‘name’: ‘bill’, ‘age’: 40}, {‘name’: ‘mike’, ‘age’: 41}]
[{‘name’: ‘mike’, ‘age’: 41}, {‘name’: ‘bill’, ‘age’: 40}, {‘name’: ‘anna’, ‘age’: 36}]

13、哪些类型的数据不能作为字典的键值

题目1：有哪些类型的数据不能作为字典的键值？
题目2：为什么列表和字典类型的值不能作为字典的键值？

d[1,2,3]=3  #错误
d[{'a:',3}]=4 #错误

列表和字典不能作为字典的键值
因为key是不能变的。但列表和字典的值是可以变化的，一旦变化，就再也找不到对应的value了。

14、如何对产生器类型的对象使用切片

from itertools import islice
gen=iter(range(10))
print(type(gen))
for i in islice(gen,2,6):
    print(i)

<class ‘range_iterator’>
2
3
4
5

itertools模块中的islice函数可以使用分片获取产生器类型对象中的部分元素，islice(产生器,开始索引,结束索引)。

15、将循环参数的列表变成产生器

a=[i for i in range(10)]
print(type(a))

b=(i for i in range(10))
print(type(b))

<class ‘list’>
<class ‘generator’>

如果列表是由for循环产生的，只需要将方括号变成圆括号，就会将列表变成一个产生器（不是由循环产生的，此法无效）。

16、Python字典与JSON字符串如何互转

a={'a':123,'b':323,'c':'xyz'}
print(a)
print(type(a))

import json
json_str=json.dumps(a)#字典转换为json字符串
print(json_str)
print(type(json_str))

a1=json.loads(json_str)#json字符串转换为字典
print(a1)
print(type(a1))

{‘a’: 123, ‘b’: 323, ‘c’: ‘xyz’}
<class ‘dict’>
{“a”: 123, “b”: 323, “c”: “xyz”}
<class ‘str’>
{‘a’: 123, ‘b’: 323, ‘c’: ‘xyz’}
<class ‘dict’>

使用dumps函数将字典转换为json字符串，使用loads函数json字符串转换为字典。

勤勤恳恳的勤勤

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Python面试100讲（二）列表、元组、字典

1、对列表（元组）去重在Python中如何定义集合，集合和列表有什么区别a=[1,2,3]#列表，中括号print(type(a))<class ‘list’>b=(1,2,3)#元组，小括号print(type(b))<class ‘tuple’>c={1,2,2,3}#集合，大括号print(c)#自动去重print(type(c))...
复制链接

扫一扫