软件工程师的试炼之地：53道Python面试问答

全文共7439字，预计学习时长32分钟

图源：unsplash

不久前我才通过面试，入职成为了“数据科学家”，但我实际上做的却是“Python工程师”的工作。如果能提前复习Python线程生命周期的知识，而不是推荐系统，我可以准备得更好。

出于这种想法，我整理了python面试或准备求职用的问题和答案。大多数数据科学家会编写大量代码，因此这均适用于数据科学家和软件工程师。

无论你是准备面试抑或是复习Python知识，这份清单都将能够帮到你。

问题不分先后，我们开始吧！

1．列表和元组有什么区别？

每次python或数据科学面试中，我都被问到过这个问题。求职者应对这个答案了如指掌。

· 列表是可变的。创建后可被修改。

· 元组是不可变的。一旦创建了元组，就不能更改

· 列表有顺序，是有序序列，通常是相同类型的对象。即：按创建日期排序的所有用户名，[” Seth”，” Ema”，” Eli”]

· 元组有结构。每个索引中可能存在不同的数据类型。即：内存中的数据库记录，（2，” Ema”，” 2020–04–16″）＃id, name,created_at

2.”is”和” ==”有什么区别？

在我初学python时，我以为它们是相同的……却出现了一些bug。因此，为了记录，is表示检查身份，而==表示检查相等性。

可通过一个例子来解释。创建一些列表并将其分配给名称。请注意，b指向与下面的a相同的对象。

a = [1,2,3]b = ac = [1,2,3]

检查是否相等，并注意它们是否全都相等。

print(a == b)print(a == c)#=> True#=> True

但是它们具有相同的身份吗？不。

print(a is b)print(a is c)#=> True#=> False

我们可以通过打印其对象ID进行验证。

print(id(a))print(id(b))print(id(c))#=>4369567560#=> 4369567560#=>4369567624

c与a和b具有不同的ID。

3.什么是装饰器？

这个问题每次面试都会问到。问题本身值得再写一篇文章，但是如果可以逐步编写自己的示例，那么就已经准备好回答这个问题了。

图源：unsplash

装饰器允许通过将现有函数传递给装饰器，从而将功能添加到现有函数，该装饰器将执行现有函数以及其他代码。

编写一个装饰器，该装饰器会在调用另一个函数时记录日志。

编写装饰器函数。这需要一个函数func作为参数。它还定义了一个函数log_function_called，该函数调用func（）并执行一些代码print（f'{func}called。’）。然后返回定义的函数

deflogging(func):    def log_function_called():      print(f'{func} called.')        func()        return log_function_called

编写其他函数，最终将装饰器添加进去（但尚未）。

def my_name():  print('chris')def friends_name():  print('naruto')my_name()friends_name()#=> chris#=> naruto

现在将装饰器添加到两者。

@loggingdef my_name(): print('chris')@loggingdef friends_name(): print('naruto')my_name()friends_name()#=> <function my_name at 0x10fca5a60> called.#=> chris#=> <function friends_name at 0x10fca5f28> called.#=> naruto

了解现在如何仅通过在其上面添加@logging就能轻松地将日志添加到编写的任何函数中。

4.如何实现字符串插值？

在不导入Template类的情况下，有3种实现字符串插值的方法。

name = 'Chris'# 1. f stringsprint(f'Hello {name}')# 2. % operatorprint('Hey %s %s' % (name, name))# 3. formatprint( "My name is {}".format((name)))

5.解释range函数

Range生成一个整数列表，有3种使用方式。

该函数接受1到3个参数。请注意，将每种用法都包装在列表解析中，以便看到生成的值。

range（stop）：生成从0到”stop”整数的整数。

[i for i in range(10)]#=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

range（start，stop）：生成从” start”到” stop”整数的整数。

[i for i in range(2,10)]#=> [2, 3, 4, 5, 6, 7, 8, 9]

range（start，stop，step）：以” step”为间隔生成从” start”到” stop”的整数。

[i for i in range(2,10,2)]#=> [2, 4, 6, 8]

6.定义一个名为car的类，具有2个属性，即”颜色”和”速度”。然后创建一个实例并返回速度。

class Car :    def __init__(self, color, speed):        self.color = color        self.speed = speedcar =Car('red','100mph')car.speed#=> '100mph'

7.python中的实例方法，静态方法和类方法之间有什么区别？

实例方法：接受self参数并与类的特定实例相关。

静态方法：使用@staticmethod装饰器，与特定实例无关，并且是独立的（请勿修改类或实例属性）

类方法：接受cls参数并可以修改类本身

举例说明一个虚构的CoffeeShop类的区别。

class CoffeeShop:    specialty = 'espresso'     def __init__(self, coffee_price):        self.coffee_price = coffee_price      # instance method    def make_coffee(self):        print(f'Making {self.specialty}for ${self.coffee_price}')       # static method       @staticmethod    def check_weather():        print('Its sunny')    # class method    @classmethod    def change_specialty(cls, specialty):        cls.specialty = specialty        print(f'Specialty changed to{specialty}')

CoffeeShop类具有specialty的属性，默认情况下设置为” espresso”。CoffeeShop的每个实例都使用属性coffee_price初始化。它还有3种方法，实例方法、静态方法和类方法。

图源：unsplash

以coffee_price为5初始化咖啡店的实例。然后调用实例方法make_coffee。

coffee_shop = CoffeeShop('5')coffee_shop.make_coffee()#=> Making espresso for $5

现在调用静态方法。静态方法无法修改类或实例状态，因此通常用于实用程序功能，例如，添加两个数字。我们用其来检查天气。Its sunny。真棒！

coffee_shop.check_weather()#=> Itssunny

现在使用类方法来修改咖啡店的特色菜，然后再修改make_coffee。

coffee_shop.change_specialty('dripcoffee')#=> Specialty changed to drip coffeecoffee_shop.make_coffee()#=> Making drip coffee for $5

请注意，make_coffee以前是用来制作espresso 的，但现在却可以制作drip coffee！

8.解释filter函数的运行原理

顾名思义，Filter函数的运行原理是按顺序过滤元素。

每个元素都传递给一个函数，如果函数返回True，则按输出顺序返回；如果函数返回False，则将其丢弃。

def add_three(x):    if x % 2 == 0:        return True           else:        return Falseli =[1,2,3,4,5,6,7,8][i for i in filter(add_three, li)]#=> [2, 4, 6, 8]

请注意如何删除所有不能被2整除的元素。

9.python是按引用调用还是按值调用？

如果已经搜索了这个问题并阅读了前几页，请准备好深入了解语义。最好仅了解其工作原理。

不变的对象，如字符串，数字和元组是按值调用的。请注意，在函数内部进行修改后，name的值不会在函数外部发生变化。name的值已分配给该功能范围内的内存中的新块。

name = 'chr'def add_chars(s):    s += 'is'    print(s)   add_chars(name)   print(name)#=> chris#=> chr

可变对象，如list，按引用调用。注意在函数外部定义的列表是如何在函数内部被修改的。函数中的参数指向内存中存储li值的原始块。

li = [1,2]def add_element(seq):    seq.append(3)    print(seq)add_element(li)   print(li)#=> [1, 2, 3]#=> [1, 2, 3]

10.如何撤消列表？

请注意如何在列表上调用reverse（）并对其进行突变。它不会返回变异列表本身。

li = ['a','b','c']print(li)li.reverse()print(li)#=> ['a', 'b', 'c']#

11.说明map函数的工作原理

map通过将函数应用于序列中的每个元素，返回由返回值组成的列表。

def add_three(x):    return x + 3li = [1,2,3][i for i inmap(add_three, li)]#=> [4, 5, 6]

上面，列表中的每个元素都添加了3。

12.字符串乘法如何工作？

让我们看看将字符串‘cat’乘以3的结果。

'cat' * 3#=> 'catcatcat'

该字符串将自身连接3次。

13.列表乘法如何工作？

我们来看看将列表[1,2,3]乘以2的结果。

[1,2,3] * 2#=> [1, 2,3, 1, 2, 3]1

输出包含重复两次的[1,2,3]内容的列表。

14.在类上”self”指的是什么？

self是指类本身的实例。这就是我们赋予方法访问权限并能够更新方法所属对象的能力。

图源：unsplash

下面，将self传递给__init __（）使我们能够在初始化时设置实例的颜色。

class Shirt:    def __init__(self, color):        self.color = color       s = Shirt('yellow')s.color#=> 'yellow'

15.如何连接python中的列表？

将2个列表加在一起并进行串联。请注意，数组的功能不同。

a = [1,2]b = [3,4,5]a + b#=> [1, 2, 3, 4, 5]

16.浅拷贝和深拷贝之间有什么区别？

在可变对象（列表）的情境下进行讨论。对于不可变对象，浅与深并不重要。

这里介绍3种情况。

一是引用原始对象。这将新名称li2指向li1在内存中指向的相同位置。因此，对li1所做的任何更改也会在li2中发生。

li1 = [['a'],['b'],['c']]li2 = li1li1.append(['d'])print(li2)#=> [['a'], ['b'], ['c'], ['d']]

二是创建原始文档的浅拷贝。可以使用list（）构造函数来做到这一点。浅拷贝会创建一个新对象，但会引用原始对象来填充它。因此，将新对象添加到原始集合li3中不会传播到li4，但是修改li3中的一个对象将传播到li4。

li3 = [['a'],['b'],['c']]li4 = list(li3)li3.append([4])print(li4)#=> [['a'], ['b'], ['c']]li3[0][0] = ['X']print(li4)#=> [[['X']], ['b'], ['c']]

三是创建一个深拷贝。这是通过copy.deepcopy（）完成的。现在，这两个对象是完全独立的，并且对其中任何一个做出更改不会对另一个对象产生影响。

import copyli5 =[['a'],['b'],['c']]li6 = copy.deepcopy(li5)li5.append([4])li5[0][0] = ['X']print(li6)#=> [['a'], ['b'], ['c']]=>

17.如何连接两个数组？

请记住，数组不是列表。数组来自Numpy和算术函数，例如线性代数。

需要使用Numpy的连接函数来实现。

import numpy as npa =np.array([1,2,3])b = np.array([4,5,6])np.concatenate((a,b))#=> array([1, 2, 3, 4, 5, 6])

18.喜欢Python的原因？

Python非常易读，并且有一种Python方式可以处理几乎所有事情，这意味着它是一种简洁明了的首选方式。

将其与Ruby相比，后者通常有很多方法来做某事，而没有指南来说明哪个是首选。

图源：unsplash

19.最喜欢使用Python的哪个库？

当处理大量数据时，没有什么比pandas库那么实用了，这使得操作和可视化数据变得轻而易举。

20.命名可变和不可变的对象

不可变表示创建后无法修改状态。例如：int、float、bool、string和tuple。

可变表示状态在创建后可以进行修改。比如列表、字典和集合。

21.如何将数字四舍五入到小数点后三位？

使用round（value，decimal_places）函数。

a = 5.12345round(a,3)#=> 5.123

22.如何分割列表？

切片符号采用3个参数list [start：stop：step]，其中step是返回元素的间隔。

a =[0,1,2,3,4,5,6,7,8,9]print(a[:2])#=> [0, 1]print(a[8:])#=> [8, 9]print(a[2:8])#=> [2, 3, 4, 5, 6, 7]print(a[2:8:2])#=> [2, 4, 6]

23.列表和数组有什么区别？

注意：Python的标准库有一个数组对象，但在这里专门指的是常用的Numpy数组。

· 列表存在于python的标准库中，数组由Numpy定义。

· 列表可以在每个索引处填充不同类型的数据，数组需要齐次元素。

· 列表上的运算可以从列表中添加或删除元素，数组函数进行线性代数运算。

· 数组占用内存少，功能更多。

有关数组的知识值得再写一篇文章。

24.什么是pickling？

picking是在Python中序列化和反序列化对象的协助方法。

在下面的示例中，对字典列表进行序列化和反序列化。

import pickleobj = [    {'id':1, 'name':'Stuffy'},    {'id':2, 'name': 'Fluffy'}]with open('file.p', 'wb') as f:    pickle.dump(obj, f)withopen('file.p', 'rb') as f:    loaded_obj =pickle.load(f)print(loaded_obj)#=> [{'id': 1, 'name': 'Stuffy'}, {'id': 2, 'name': 'Fluffy'}]

25.字典和JSON有什么区别？

Dict是python数据类型，是已索引但无序的键和值的集合。

JSON只是遵循指定格式的字符串，用于传输数据。

26.在Python中使用了哪些ORM？

ORM（对象关系映射）将数据模型（通常在应用程序中）映射到数据库表，并简化了数据库操作。

SQLAlchemy通常在Flask的上下文中使用，而Django拥有自己的ORM。

['c', 'b', 'a']

27.any（）和all（）如何工作？

Any接受一个序列，如果序列中的任一元素为true，则返回true。

仅当序列中的所有元素均为true时，All才返回true。

a = [False, False, False]b = [True, False, False]c = [True, True, True]print( any(a) )print( any(b) )print( any(c) )#=> False#=> True#=> Trueprint( all(a) )print( all(b) )print( all(c) )#=> False#=> False#=> True

28.字典或列表的查找速度更快吗？

在列表中查找值需要O（n）时间，因为需要遍历整个列表直到找到值为止。

在字典中查找键需要O（1）时间，因为它是一个哈希表。

如果值很多，时间可能会相差很大，因此通常建议使用字典来提高速度。但是它们确实还有其他限制，例如需要唯一键。

图源：unsplash

29.如何返回整数的二进制？

使用bin（）函数。

bin(5)#=>'0b101'

30.如何从列表中删除重复的元素？

可以通过将列表转换为集合然后返回列表来完成。

a = [1,1,1,2,3]a = list(set(a))print(a)#=> [1, 2, 3]

31.如何检查列表中是否存在值？

使用in。

'a' in ['a','b','c']#=> True'a' in [1,2,3]#=> False

32.append和extend有什么区别？

append将值添加到列表，而extend将另一个列表中的值添加到这个列表。

a = [1,2,3]b = [1,2,3]a.append(6)print(a)#=> [1, 2, 3, 6]b.extend([4,5])print(b)#=> [1, 2, 3, 4, 5]

33.如何取整数的绝对值？

这可以通过abs（）函数来完成。

abs(2)#=> 2abs(-2)#=> 2

34.如何将两个列表组合成一个元组列表？

可以使用zip函数将列表组合成一个元组列表。这不仅限于仅使用两个列表。也可以用3个或更多来完成。

a = ['a','b','c']b = [1,2,3][(k,v) for k,v in zip(a,b)]#=> [('a', 1), ('b', 2), ('c', 3)]

35.如何按字母顺序对字典排序？

无法对字典进行”排序”，因为字典没有顺序，但是可以返回已排序的元组列表，其中包含字典中的键和值。

d = {'c':3, 'd':4, 'b':2,'a':1}sorted(d.items())#=> [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

36.一个类如何从Python中的另一个类继承？

在下面的示例中，Audi继承自Car。继承带来了父类的实例方法。

class Car():    def 
                                                        
声明：本站部分文章及图片转载于互联网，内容版权归原作者所有，如本站任何资料有侵权请您尽早请联系jinwei@zod.com.cn进行处理,非常感谢！