疫情期间，很多IT公司公司都倒闭了，很多人都失业了。在全面复工后，很多IT人就开始了漫长的面试过程，不敢去大公司，担心自己实力不够，面试的问题怕回答不上来，也不敢去小公司，怕它随时倒下。这里面的IT人就包含了一批Python工程师，下面我给大家整理了一些企业招Python工程师时常问的面试题，帮助大家找到更好的公司！

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

我在每一次python/data science面试中都被问过这个问题。

• 列表是可变的。它们可以在创建后修改。

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

• 列表有顺序。它们是同一类型对象的有序序列。Ie：按创建日期排序的所有用户名，[“Seth”，“Ema”，“Eli”]

• 元组有结构。每个索引中可能存在不同的数据类型。即：内存中的数据库记录， (2, "Ema", "2020–04–16") # id, name, created_at

2.如何执行字符串插值？

在不导入模板类的情况下，有3种方法可以插入字符串。

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

3.“is”和“==”有什么区别？

对于记录，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的id与a和b不同。

4.什么是装饰器（decorator）？

这是每次面试我都会被问到的另一个问题。

decorator允许通过将现有函数传递给decorator来向现有函数添加功能，decorator将执行现有函数和其他代码。

我们将编写一个decorator，它在调用另一个函数时记录日志。

编写decorator函数。它接受一个函数func作为参数。它还定义了一个名为log function的函数，它调用func（）并执行一些print（f'{func}called.'）的代码，然后返回它定义的函数。

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

让我们编写其他函数，我们最终会将decorator添加到其中。

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

现在将decorator添加到两者。

@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来轻松地将日志添加到我们编写的任何函数中。

5.解释range函数

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

函数接受1到3个参数。注意，我已经将每个用法包装在列表理解中，以便我们可以看到生成的值。

range(stop)：生成从0到“停止”整数的整数。

[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]

range(start, stop, step) :以“step”为间隔生成从“start”到“stop”的整数。

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

6.定义一个名为car的类，它有两个属性：“color”和“speed”。然后创建一个实例并返回速度。

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

7.python中的instance、static和class方法有什么区别？

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

静态方法：使用@staticmethod decorator，与特定实例无关，并且是自包含的（不要修改类或实例属性）

类方法：接受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的每个实例都用CoffeePrice属性初始化。它还有3个方法：实例方法、静态方法、类方法。

让我们初始化咖啡店的一个实例，咖啡价格为5。然后调用实例方法make_coffee。

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

现在开始调用静态方法，静态方法无法修改类或实例状态，因此通常用于实用程序函数，例如，添加2个数字。

coffee_shop.check_weather()#=> Its sunny

现在让我们使用类方法修改咖啡店的特色，然后make_coffee。

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

注意，make_coffee过去是用来做浓缩咖啡的，但现在是用来做滴咖啡的！

8.“func”和“func（）”有什么区别？

这个问题的目的是看看您是否理解所有函数也是python中的对象。

def func():    print('Im a function')    func#=> function __main__.func>func()    #=> Im a function

func是表示函数的对象，它可以被分配给变量或传递给另一个函数。带圆括号的func（）调用函数并返回其输出。

9.解释map函数的工作原理

map返回一个列表，该列表由对序列中的每个元素应用函数时返回的值组成。

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

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

10.解释reduce函数的工作原理

在你使用它几次之前，要把你的头裹起来是很难的。

reduce接受一个函数和一个序列并在该序列上迭代。每次迭代时，当前元素和前一个元素的输出都传递给函数。最后，返回一个值。

from functools import reducedef add_three(x,y):    return x + yli = [1,2,3,5]reduce(add_three, li)#=> 11

返回11，即1+2+3+5的和。

11.解释过滤器功能的工作原理

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整除的元素是如何被移除的。

12.python是通过引用调用还是通过值调用？

如果你在谷歌上搜索这个问题并阅读，你就要准备好进入语义的胡同了。

字符串、数字和元组等不可变对象是按值调用的。请注意，当在函数内部修改时，name的值在函数外部没有更改。name的值已分配给内存中该函数作用域的新块。

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

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

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

13.如何反转list？

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

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

14.字符串乘法是如何工作的？

让我们看看字符串“cat”乘以3的结果。

'cat' * 3#=> 'catcatcat'

字符串被连接到自身3次。

15.列表乘法是如何工作的？

让我们看看把一个列表[1,2,3]乘以2的结果。

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

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

16.“self”在类中代表什么？

Self引用类本身的实例。这就是我们如何让方法访问和更新它们所属的对象的能力。

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

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

17.如何在python中连接列表？

将两个列表加在一起将它们连接起来。请注意，数组的功能是不同的。

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

18.浅拷贝和深拷贝有什么区别？

我们将在一个可变对象的上下文中讨论这个问题，一个列表，对于不可变的对象，shallow和deep没有那么相关。

我们将经历三个场景。

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

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

ii）创建原始文件的浅显副本。我们可以使用 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']]

iii）创建一个深度副本。这是用copy.deepcopy（）完成的。这两个对象现在完全独立，对其中一个的更改对另一个没有影响。

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

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

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

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

• 列表上的算术运算可从列表中添加或删除元素。每个线性代数的数组函数的算术。

• 阵列也使用更少的内存，并且具有更多的功能。

20.如何连接两个数组？

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

我们需要使用Numpy的concatenate函数来完成它。

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])

21.你喜欢Python什么？

Python可读性很强，有一种Python的方式来处理所有事情，这意味着首选的方式是清晰和简洁的。

我将此与Ruby进行对比，Ruby通常有很多方法可以在没有指导原则的情况下做一些事情。

22.你最喜欢的Python库是什么？

在处理大量数据时，没有什么比熊猫更有用了，因为熊猫可以轻松地处理和可视化数据。

23.命名可变和不可变对象

不可变意味着创建后不能修改状态。例如：int、float、bool、string和tuple。

可变意味着可以在创建后修改状态。例如list、dict和set。

24.你怎么把一个数字四舍五入到小数点后三位？

使用round（值，小数位数）函数。

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

25.你怎么把 list 切片？

切片表示法有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]

26.什么是Pickling？

Pickling是Python中序列化和取消序列化对象的常用方法。

在下面的示例中，我们序列化和取消序列化字典列表。

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

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

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

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

28.你在Python中使用了什么ORMs？

ORMs（对象关系映射）将数据模型（通常在应用程序中）映射到数据库表并简化数据库事务。

SQLAlchemy通常用于Flask的上下文中，Django有自己的ORM。

29.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

30.字典或列表查找速度快吗？

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

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

如果有很多值，这会造成很大的时间差异，因此通常建议使用字典来提高速度。但它们也有其他限制，比如需要唯一的密钥。

31.模块和包有什么区别？

模块是可以一起导入的文件（或文件集合）。

import sklearn

包是模块的目录。

from sklearn import cross_validation

以包是模块，但不是所有的模块都是包。

32.如何在Python中增减整数？

递增和递减可以用+和-=。

value = 5value += 1print(value)#=> 6value -= 1value -= 1print(value)#=> 4

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

使用bin（）函数。

bin(5)#=> '0b101'

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

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

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

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

使用 in。

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

36.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]

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

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

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

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

可以使用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)]

39.你怎么能按字母顺序按键给词典排序？

不能对字典“排序”，因为字典没有顺序，但可以返回一个已排序的元组列表，其中包含字典中的键和值。

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

40.在Python中，一个类如何从另一个类继承？

在下面的例子中，奥迪继承了汽车。继承带来了父类的实例方法。

class Car():    def drive(self):        print('vroom')class Audi(Car):    passaudi = Audi()audi.drive()

41.如何从字符串中删除所有空格？

最简单的方法是在空白处拆分字符串，然后在没有空格的情况下重新连接。

s = 'A string with     white space'''.join(s.split())#=> 'Astringwithwhitespace'

42.为什么在迭代序列时要使用 enumerate（）呢？

enumerate() 允许在序列上迭代时跟踪索引，它比定义和递增一个表示索引的整数更像Python。

li = ['a','b','c','d','e']for idx,val in enumerate(li):    print(idx, val)#=> 0 a#=> 1 b#=> 2 c#=> 3 d#=> 4 e

43.pass, continue and break有什么区别？

pass意味着什么都不做。我们通常使用它是因为Python不允许在没有代码的情况下创建类、函数或if语句。

在下面的示例中，如果i>3中没有代码，就会抛出一个错误，因此我们使用 pass 。

a = [1,2,3,4,5]for i in a:    if i > 3:        pass    print(i)#=> 1#=> 2#=> 3#=> 4#=> 5

continue 继续下一个元素并停止当前元素的执行。所以当i<3时，永远不会达到print（i）。

for i in a:    if i < 3:        continue    print(i)#=> 3#=> 4#=> 5

break 中断循环，序列不再迭代。所以从3开始的元素不会被打印。

for i in a:    if i == 3:        break    print(i)    #=> 1#=> 2

44.将以下for循环转换为列表理解。

这是循环。

a = [1,2,3,4,5] a2 = []for i in a:     a2.append(i + 1)print(a2)#=> [2, 3, 4, 5, 6]

变成：

a3 = [i+1 for i in a]print(a3)#=> [2, 3, 4, 5, 6]

列表理解通常被认为是更易读的。

45.给出三元运算符的一个例子

三元运算符是单行 if/else 语句。

语法看起来像 if 条件 else b。

x = 5y = 10'greater' if x > 6 else 'less'#=> 'less''greater' if y > 6 else 'less'#=> 'greater'

46.检查字符串是否只包含数字。

你可以使用isnumeric（）。

'123a'.isnumeric()#=> False'123'.isnumeric()#=> True

47.检查字符串是否只包含字母。

你可以使用isalpha（）。

'123a'.isalpha()#=> False'a'.isalpha()#=> True

48.检查字符串是否只包含数字和字母。

你可以使用isalnum（）。

'123abc...'.isalnum()#=> False'123abc'.isalnum()#=> True

49.从字典中返回密钥列表。

这可以通过将字典传递给python的 list（）构造函数 list（）来完成。

d = {'id':7, 'name':'Shiba', 'color':'brown', 'speed':'very slow'}list(d)#=> ['id', 'name', 'color', 'speed']

50.你怎么把一个字符串大写和小写？

可以使用 upper（）和 lower（）字符串方法。

small_word = 'potatocake'big_word = 'FISHCAKE'small_word.upper()#=> 'POTATOCAKE'big_word.lower()#=> 'fishcake'

51.remove, del 和 pop有什么区别？

remove（）删除第一个匹配值。

li = ['a','b','c','d']li.remove('b')li#=> ['a', 'c', 'd']

del 按索引删除元素。

li = ['a','b','c','d']del li[0]li#=> ['b', 'c', 'd']

pop() 按索引移除元素并返回该元素。

li = ['a','b','c','d']li.pop(2)#=> 'c'li#=> ['a', 'b', 'd']

52.举一个字典理解的例子。

下面我们将创建一个字典，其中字母表中的字母作为键，字母表中的索引作为值。

# creating a list of lettersimport stringlist(string.ascii_lowercase)alphabet = list(string.ascii_lowercase)# list comprehensiond = {val:idx for idx,val in enumerate(alphabet)} d#=> {'a': 0,#=>  'b': 1,#=>  'c': 2,#=> ...#=>  'x': 23,#=>  'y': 24,#=>  'z': 25}

53.在Python中如何执行异常处理？

Python提供了3个字来处理异常、try、except和finally。

语法如下：

try:    # try to do thisexcept:    # if try block fails then do thisfinally:    # always do this

在下面的简单示例中，try块失败，因为我们不能添加带字符串的整数。except块设置val=10，然后最终块打印完成。

try:    val = 1 + 'A'except:    val = 10finally:    print('complete')    print(val)#=> complete#=> 10

结论

你永远不知道面试中会出现什么问题，最好的准备方法是有足够多编写代码的经验和知道面试官会问什么。

也就是说，这里整理了应该涵盖python所要求的数据科学家或初级/中级python开发人员角色的大部分内容。希望对各位求职者有帮助！

--END--

欢迎大家关注我们的公众号：为AI呐喊（weainahan）

找工作一定少不了项目实战经验，为了帮助更多缺少项目实战的同学入门Python，我们在头条上创建了一个专栏：《7小时快速掌握Pthon核心编程》，通过一个项目，快速掌握Python，欢迎大家点击下方链接或者阅读原文进行试看~