疫情期间，很多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 strings
print(f'Hello {name}')
# 2. % operator
print('Hey %s %s' % (name, name))
# 3. format
print(
 "My name is {}".format((name))
)

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

对于记录，is检查标识，而==检查相等性。

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

a = [1,2,3]
b = a
c = [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添加到两者。

@logging
def my_name():
 print('chris')
@logging
def friends_name():
 print('naruto')
my_name()
friends_name()
#=>  called.
#=> chris
#=>  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 = speed
car = 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 coffee
coffee_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 + 3
li = [1,2,3]
[i for i in map(add_three, li)]
#=> [4, 5, 6]

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

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

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

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

from functools import reduce
def add_three(x,y):
    return x + y
li = [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 False
li = [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 = li1
li1.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 copy
li5 = [['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 np
a = 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.12345
round(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 pickle
obj = [
    {'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
#=> True
print( 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 = 5
value += 1
print(value)
#=> 6
value -= 1
value -= 1
print(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)
#=> 2
abs(-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):
    pass
audi = 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 = 5
y = 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 letters
import string
list(string.ascii_lowercase)
alphabet = list(string.ascii_lowercase)
# list comprehension
d = {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 this
except:
    # if try block fails then do this
finally:
    # always do this

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

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

结论

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

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

--END--

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

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