爬虫工程师面试题

绝地灬酷狼 2023-09-30 00:53 18阅读 0赞

为了找工作而做准备。

一、题目部分

1、python中常用的数据结构有哪些？请简要介绍一下。  
2、简要描述python中单引号、双引号、三引号的区别。  
3、如何在一个function里设置一个全局的变量。  
4、python里面如何拷贝一个对象？（赋值、浅拷贝、深拷贝的区别）  
5、如果custname字符串的编码格式为uft-8,如何将custname的内容转化为gb18030的字符串？  
6、请写出一段python代码实现删除list中的重复元素。  
7、这两个参数是什么意思？args和 kwargs。  
8、  
（1）统计如下list单词及其出现的次数。  
a=\[‘apple’, ‘banana’, ‘apple’, ‘tomato’, ‘orange’, ‘apple’, ‘banana’, ‘watermeton’\]

（2）给列表中的字典排序：例如有如下list对象：  
alist=\[\{“name”:“a”, “age”:20\}, \{“name”:“b”, “age”:30\}, \{“name”:“c”, “age”:25\}\] 将alist中的元素按照age从小到大排序。

（3）写出下列代码的运行结果  
1 a = 1  
2 def fun(a):  
3 a = 2  
4 fun(a)  
5 print(a)  
1 a = \[\]  
2 def fun(a):  
3 a.append(1)  
4 fun(a)  
5 print(a)  
复制代码  
1 class Person:  
2 name = ‘Lily’  
3  
4 p1 = Person()  
5 p2 = Person()  
6 p1.name = ‘Bob’  
7 print(p1.name)  
8 print(p2.name)  
9 print(Person.name)  
复制代码  
二、解答部分

注：以下答案，均为google后结合自己学所知识回答，可能会有不正确的地方，错误之处希望大家帮我指正出来，谢谢。

1、python中常用的数据结构有哪些？请简要介绍一下。  
python中常见的数据结构有：列表(list)，字典(dict)，元组(tuple)，字符串(string)，集合(set)，数字（int或long或float。。。）等。

其中，列表，元祖和字符串可以统一归为序列类，即这三种数据结构中的元素是有序的。比如，他们都有索引（下标）操作，还有切片、相加和长度(len)，最大值(max)，最小值(min)操作。这是他们的共同点。

补充：python中常见的数据结构可以统称为容器（container）。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。

另外，关于这个问题，面试官很容易引出另一个问题：python中的哪些数据类型是可变的，哪些是不可变的？

首先，可变/不可变是针对该对象所指向的内存中的值是否可变来判断的。如可变类型的数据类型有列表和字典，还有集合（感谢@自由早晚乱余生纠正）。不可变类型的数据类型有字符串，元组，数字。

就举个最简单的数字的例子，python中有小整数池的概念，即\[-5,256\]范围内的整数，python解释器对他们做了特殊处理，都放在内存中的固定位置，不会因为你的操作而发生变化。

现在：a = 1 ，然后我们又重新对a赋值，a = 2，在重新赋值的过程中，整数1所对应的内存地址没有和数字的大小都没有发生变化，还在内存中的固定位置。整数2也是如此。变化的是a的指针（这里引用C中的概念）从指向数字1变成数字2。a对象指向的内存中的值没有发生变化，因此数字是不可变类型的数据类型。字符串，元组也是同理。

2、简要描述python中单引号、双引号、三引号的区别。  
首先，单引号和双引号在使用时基本上没有什么区别，唯一需要注意的是：当字符串中有单引号时，最好在外面使用双引号；当有双引号时，最好在外面使用单引号。

三引号一般不常用，除了用来做注释之外，还可以用来打印多行字符串。特殊用途，是可以打印多行字符串。

1 print(’’‘i  
2 love  
3 you’’’) \#特殊功能,可以直接打印多行内容,而前面两种情况需要显示输入\\n才能换行  
输出结果：

1 i  
2 love  
3 you  
而单引号和双引号如果想要实现上面的效果，需要加上换行符。

1 print(‘i\\nlove\\nyou’)  
3、如何在一个function里设置一个全局的变量。  
先说概念，全局变量是指定义在函数外部的变量。全局变量的作用域为全局。

局部变量是指定义在函数内部的变量。局部变量的作用域为函数内，除了函数就无效了。

这里举个例子，如果把函数比作国家，那么全局就是全球，全局变量好比是阿拉伯数字，每个国家都认识。

所以，根据定义可以知道，在函数内部是无法定义一个全局变量的，只能做到修改已经定义的全局变量。

4、python里面如何拷贝一个对象？（赋值、浅拷贝、深拷贝的区别）  
在python中如何拷贝一个对象是需要根据具体的需求来定的。

（1）赋值：其实就是对象的引用。相当于C的指针，修改了其中一个对象，另一个跟着改变。注意对于不可变对象而言，如果修改了其中一个对象，就相当于修改它的指针指向，另一个对象是不会跟着变化的。

1 a = \[‘1’, ‘2’\] \# a是一个可变对象  
2 b = a  
3 a = a.pop()  
4 print(b) \# 修改了a，b也跟着变  
输出结果：

1 \[‘1’\]  
当a为不可变对象时：

1 a = 1  
2 b = a  
3 a = 2  
4 print(‘b = \{\}’.format(b))  
输出结果：

1 b = 1

（2）浅拷贝：拷贝父对象，但是不会拷贝父对象的子对象。（具体的方法有：b = copy.copy(a)，切片如b = a\[1:4\]）

1 a = \{1: \[1, 2, 3\]\}  
2 b = a.copy()  
3 print(a, b)  
4 a\[1\].append(4)  
5 print(a, b)  
输出结果为：

\{1: \[1, 2, 3\]\} \{1: \[1, 2, 3\]\}  
\{1: \[1, 2, 3, 4\]\} \{1: \[1, 2, 3, 4\]\}  
当a为不可变对象时：

1 import copy  
2 a = ‘TEST\_STRING’  
3 b = copy.copy(a)  
4 print(a, b)  
5 a = a.lower()  
6 print(a, b)  
输出结果：

1 TEST\_STRING TEST\_STRING  
2 test\_string TEST\_STRING  
（3）深拷贝：完全拷贝了父对象和子对象（具体的方法有：b = copy.deepcopy(a)）

1 import copy  
2 a = \{1: \[1, 2, 3\]\}  
3 b = copy.deepcopy(a)  
4 print(a, b)  
5 a\[1\].append(4)  
6 print(a, b)  
输出结果：

1 \{1: \[1, 2, 3\]\} \{1: \[1, 2, 3\]\}  
2 \{1: \[1, 2, 3, 4\]\} \{1: \[1, 2, 3\]\}  
当a为不可变对象时：

1 import copy  
2 a = ‘TEST\_STRING’  
3 b = copy.deepcopy(a)  
4 print(a, b)  
5 a = a.lower()  
6 print(a, b)  
输出结果：

1 TEST\_STRING TEST\_STRING  
2 test\_string TEST\_STRING  
下面是图解：1、b = a: 赋值引用，a 和 b 都指向同一个对象。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_12_color_FFFFFF_t_70_g_se_x_16]  
2、b = a.copy(): 浅拷贝, a 和 b 是一个独立的对象，但他们的子对象还是指向统一对象（是引用）。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_12_color_FFFFFF_t_70_g_se_x_16 1]  
3、b = copy.deepcopy(a): 深度拷贝, a 和 b 完全拷贝了父对象及其子对象，两者是完全独立的。

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_13_color_FFFFFF_t_70_g_se_x_16]  
总结：

（1）当对象为不可变类型时，不论是赋值，浅拷贝还是深拷贝，那么改变其中一个值时，另一个都是不会跟着变化的。

（2）当对象为可变对象时，如果是赋值和浅拷贝，那么改变其中任意一个值，那么另一个会跟着发生变化的；如果是深拷贝，是不会跟着发生改变的。

啊，这一题答案真的是好长啊，累到掉渣！歇会儿。。。

5、如果custname字符串的编码格式为uft-8,如何将custname的内容转化为gb18030的字符串？  
先将custname编码格式转换为unicode，在转换为gb18030。即custname.encode(‘utf-8’).decode(‘gb18030’)。

注意：unicode编码是一种二进制编码，是转换编码的中间桥梁。比如需要将utf-8转换为gbk，那么就需要先转换为unicode（encode），再转为gbk（decode）。  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_20_color_FFFFFF_t_70_g_se_x_16]  
6、请写出一段python代码实现删除list中的重复元素。  
两种方法：

（1）利用字典的fromkeys来自动过滤重复值

（2）利用集合set的特性，元素是非重复的

方法一：

复制代码  
1 a = \[1, 2, 3, 4, 5, 2, 3\]  
2  
3 def fun1(a):  
4 a = list(set(a))  
5 print(a)  
6  
7 fun1(a)  
复制代码  
方法二：

复制代码  
1 a = \[1, 2, 3, 4, 5, 2, 3\]  
2  
3 def fun1(a):  
4 b = \{\}  
5 b = b.fromkeys(a)  
6 c = list(b.keys())  
7 print©  
8  
9 c = fun1(a)  
复制代码  
7、这两个参数是什么意思？args和 kwargs。  
首先，我想说的是*args和\*\*kwargs并不是必须这样写，只有前面的*和**才是必须的。你可以写成\*var和**vars。而写成\*args和\*\*kwargs只是约定俗称的一个命名规定。

\*args和\*\*kwargs主要用于函数定义，你可以将不定量的参数传递给一个函数。其中，\*args 是用来发送一个非键值对的可变数量的参数列表给一个函数；**kwargs 允许你将不定长度的键值对, 作为参数传递给一个函数。 如果你想要在一个函数里处理带名字的参数, 你应该使用**kwargs。

复制代码  
1 def import\_args(test, *args):  
2 print(‘param1’, test)  
3 for item in args:  
4 print(‘other param’, item)  
5  
6  
7 import\_args(‘123’, ‘hello’, ‘2019’)  
复制代码  
这里传递了3个参数，按位置传参，'123’为test传参，'hello’和’2019’为*args传参，这里传了2个参数。

注意，看下面的\*args的另一种用法：用来解压数据。

复制代码  
1 def import\_args(test, \*args):  
2 print(‘param1’, test)  
3 for item in args:  
4 print(‘other param’, item)  
5  
6  
7 args = \[‘hello’, ‘2019’\]  
8 import\_args(‘123’, \*args)  
复制代码  
输出结果：

1 param1 123  
2 other param hello  
3 other param 2019

这段代码和上面的效果是一样的，但是这里第8行的*args和第1行的*args可是不一样的。第一行是表示函数可以接受不定数量的非键值对的参数，用来传参使用的。第八行是用来解压列表

\[‘hello’, ‘2019’\]的每一项数据的，用来解压参数的。这是*args的两种用法，也可说是*的两种用法，因为args是可变的。

接下来说说\*\*kwargs。

复制代码  
1 def import\_kwargs(test, \*\*kwargs):  
2 print(‘param1’, test)  
3 for key, value in kwargs.items():  
4 print(key, value)  
5  
6  
7 d = \{‘name’: ‘jack’, ‘age’: 26\}  
8 import\_kwargs(‘123’, \*\*d)  
复制代码  
**kwargs用来传递带键值对的参数，而**也是用来解压字典容器内的参数。

输出结果：

1 param1 123  
2 name jack  
3 age 26  
总结：\*args和\*\*kwargs都是用于函数中传递参数的，\*args传递的是非键值对的参数，\*\*kwargs传递的是带键值对的参数，如果还有普通参数需要传递，那么应该先传递普通的参数。

8、  
（1）统计如下list单词及其出现的次数。  
a=\[‘apple’, ‘banana’, ‘apple’, ‘tomato’, ‘orange’, ‘apple’, ‘banana’, ‘watermeton’\]

方法一：

利用字典。

1 a = \[‘apple’, ‘banana’, ‘apple’, ‘tomato’, ‘orange’, ‘apple’, ‘banana’, ‘watermeton’\]  
2 dic = \{\}  
3 for key in a:  
4 dic\[key\] = dic.get(key, 0) + 1  
5 print(dic)  
输出结果：

1 \{‘apple’: 3, ‘banana’: 2, ‘tomato’: 1, ‘orange’: 1, ‘watermeton’: 1\}

方法二：

利用python的collections包。

1 from collections import Counter  
2  
3 a = \[‘apple’, ‘banana’, ‘apple’, ‘tomato’, ‘orange’, ‘apple’, ‘banana’, ‘watermeton’\]  
4 d = Counter(a)  
5 print(d)  
输出结果：

1 Counter(\{‘apple’: 3, ‘banana’: 2, ‘tomato’: 1, ‘orange’: 1, ‘watermeton’: 1\}) \# 是一个类似字典的结构  
（2）给列表中的字典排序：例如有如下list对象：  
alist=\[\{“name”:“a”, “age”:20\}, \{“name”:“b”, “age”:30\}, \{“name”:“c”, “age”:25\}\] 将alist中的元素按照age从小到大排序。

利用list的内建函数，list.sort()来进行排序。

1 alist = \[\{“name”: “a”, “age”: 20\}, \{“name”: “b”, “age”: 30\}, \{“name”: “c”, “age”: 25\}\]  
2 alist.sort(key=lambda x: x\[‘age’\])  
3 print(alist)  
这是一种效率很高的排序方法。

输出结果：

1 \[\{‘name’: ‘a’, ‘age’: 20\}, \{‘name’: ‘c’, ‘age’: 25\}, \{‘name’: ‘b’, ‘age’: 30\}\]  
（3）写出下列代码的运行结果  
第一段代码的运行结果为：1

分析，在函数外面定义了一个全局变量a为1，在函数内部定义了一个局部变量a为2。局部变量在离开函数后就失效了。

所以，结果为全局变量的a的值。如果在a=2之前加上global a，声明为全局变量，那么结果为2。

第二段代码的运行结果为：\[1\]

这是因为，将a传入到function中，这相当于对a进行赋值引用。由于a是可变类型的，所以在函数内部修改a的时候，外部的全局变量a也跟着变化。

第三段代码的运行结果为：

1 Bob  
2 Lily  
3 Lily  
以上。

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_12_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/5cf69c8510194bd6a5dbeecdcef5a0f2.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdGVhX3llYXI=,size_12,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_12_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/5602af76eefa4aad979eb587c2e8c479.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdGVhX3llYXI=,size_12,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_13_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/6f4259edc35345c6ac5e3e5b6976a727.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdGVhX3llYXI=,size_13,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAdGVhX3llYXI_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/64e396ad2d014402bf809de8e2bdd4f9.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAdGVhX3llYXI=,size_20,color_FFFFFF,t_70,g_se,x_16