53 个 Python 面试问题与答案

1. 列表（list）和元组（tuple）有什么区别？

在我每一次应聘 Python 数据科学家的面试中，这个问题都会被问到。所以对这个问题的答案，我可以说是了如指掌。

列表是可变的。创建后可以对其进行修改。
元组是不可变的。元组一旦创建，就不能对其进行更改。
列表表示的是顺序。它们是有序序列，通常是同一类型的对象。比如说按创建日期排序的所有用户名，如[“Seth”, “Ema”, “Eli”]。
元组表示的是结构。可以用来存储不同数据类型的元素。比如内存中的数据库记录，如(2, “Ema”, “2020–04–16”)（#id, 名称,创建日期）。

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

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

name = 'Chris'
# 1. f stringsprint(f'Hello {name}')

# 2. % operatorprint('Hey %s %s' % (name, name))

# 3. format
print(
 "My name is {}".format((name)))

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

在我的 Python 职业生涯的早期，我认为它们是相同的，因而制造了一些 bug。
所以请大家听好了，“is”用来检查对象的标识(id)，而“==”用来检查两个对象是否相等。
我们将通过一个例子说明。创建一些列表并将其分配给不同的名字。请注意，下面的 b 指向与 a 相同的对象。

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

下面来检查是否相等，你会注意到结果显示它们都是相等的。

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

但是它们具有相同的标识（id）吗？答案是不。

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）。

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

这是每次面试我都会被问到的另一个问题。它本身就值得写一篇文章。如果你能自己用它编写一个例子，那么说明你已经做好了准备。
装饰器允许通过将现有函数传递给装饰器，从而向现有函数添加一些额外的功能，该装饰器将执行现有函数的功能和添加的额外功能。
我们将编写一个装饰器，该装饰器会在调用另一个函数时记录日志。
编写装饰器函数logging。它接受一个函数 func 作为参数。它还定义了一个名为 log_function_called 的函数，它先执行打印出一些“函数 func 被调用”的信息（print(f'{func} called.’)），然后调用函数 func()。最后返回定义的函数。

def logging(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

现在将装饰器添加到上面编写的两个函数之中。

@logging
def my_name():
 print('chris')@logging
def 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 函数可以用来创建一个整数列表，一般用在 for 循环中。它有 3 种使用方法。
Range 函数可以接受 1 到 3 个参数，参数必须是整数。
请注意：我已经将 range 的每种用法包装在一个递推式构造列表（list comprehension）中，以便我们可以看到生成的值。

用法1 – range(stop)：生成从0到参数“stop”之间的整数。

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

用法2 – range(start, stop) : 生成从参数“start”到“stop”之间的整数。

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

用法3 – range(start, stop, step)：以参数“step”为步长，生成从“start”到“stop”之间的整数。

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

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

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 个方法，一个实例方法，一个静态方法和一个类方法。

让我们将 coffee_price 的值设为 5，来初始化 CoffeeShop 的一个实例。然后调用实例方法 make_coffee。

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

现在我们来调用静态方法。静态方法无法修改类或实例状态，因此通常用于工具函数，例如，把 2 个数字相加。我们这里用它来检查天气。天气晴朗。太好了！

coffee_shop.check_weather()
#=> Its sunny

现在让我们使用类方法修改 CoffeeShop 的属性 specialty，然后调用 make_coffee() 方法来制作咖啡。

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

注意，make_coffee 过去是用来做意式浓缩咖啡（espresso）的，但现在用来做滴滤咖啡（drip 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 reduce
def add_three(x,y):
    return x + y
    li = [1,2,3,5]
    reduce(add_three, li)
#=> 11

返回 11，它是1 + 2 + 3 + 5的总和。