本文转载自公众号“读芯术”(ID：AI_Discovery)
不久前我才通过面试，入职成为了“数据科学家”，但我实际上做的却是“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 = 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与a和b具有不同的ID。
3. 什么是装饰器?
这个问题每次面试都会问到。问题本身值得再写一篇文章，但是如果可以逐步编写自己的示例，那么就已经准备好回答这个问题了。
装饰器允许通过将现有函数传递给装饰器，从而将功能添加到现有函数，该装饰器将执行现有函数以及其他代码。
编写一个装饰器，该装饰器会在调用另一个函数时记录日志。
编写装饰器函数。这需要一个函数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
现在将装饰器添加到两者。
- @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就能轻松地将日志添加到编写的任何函数中。
4. 如何实现字符串插值?
在不导入Template类的情况下，有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))
- )
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是指类本身的实例。这就是我们赋予方法访问权限并能够更新方法所属对象的能力。
下面，将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 npnpa =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相比，后者通常有很多方法来做某事，而没有指南来说明哪个是首选。
19. 最喜欢使用Python的哪个库?
当处理大量数据时，没有什么比pandas库那么实用了，这使得操作和可视化数据变得轻而易举。
20. 命名可变和不可变的对象
不可变表示创建后无法修改状态。例如：int、float、bool、string和tuple。
可变表示状态在创建后可以进行修改。比如列表、字典和集合。
21. 如何将数字四舍五入到小数点后三位?
使用round(value，decimal_places)函数。
- a = 5.12345
- round(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)时间，因为它是一个哈希表。
如果值很多，时间可能会相差很大，因此通常建议使用字典来提高速度。但是它们确实还有其他限制，例如需要唯一键。
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 drive(self):
- print('vroom')class Audi(Car):
- passaudi = Audi()
- audi.drive()
37. 模块和包装之间有什么区别?
模块是可以一起导入的文件(或文件集合)。
- importsklearn
包是模块的目录。
- from sklearnimport cross_validation
因此，包是模块，但并非所有模块都是包。
38. 如何在Python中递增和递减整数?
可以使用+-和-=进行递增和递减。
- value = 5value += 1
- print(value)
- #=> 6value -= 1
- value -= 1
- print(value)
- #=> 4
39. 如何从字符串中删除所有空格?
最简单的方法是在空白处分割字符串，然后重新连接而没有空格。
- s = 'A string with white space'''.join(s.split())
- #=> 'Astringwithwhitespace'
40. 为什么要在迭代序列时使用enumerate()?
enumerate()允许在迭代序列时跟踪索引。它比定义和递增代表索引的整数更具Python感。
- li = ['a','b','c','d','e']foridx,val in enumerate(li):
- print(idx, val)
- #=> 0 a
- #=> 1 b
- #=> 2 c
- #=> 3 d
- #=> 4 e
41. pass、continue和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
42. 举例说明三元运算符。
三元运算符是单行if / else语句。
句法看起来像a if condition else b.。
- x = 5
- y = 10'greater' if x > 6 else 'less'
- #=> 'less''greater' if y > 6 else 'less'
- #=> 'greater'
43. 检查字符串是否仅包含数字。
可以使用isnumeric().
- '123a'.isnumeric()
- #=> False'123'.isnumeric()
- #=> True
44. 检查字符串是否仅包含字母。
可以使用isalpha().
- '123a'.isalpha()
- #=> False'a'.isalpha()
- #=> True
45. 检查字符串是否仅包含数字和字母。
您可以使用isalnum().
- '123abc...'.isalnum()
- #=> False'123abc'.isalnum()
- #=> True
46. 从字典返回键列表。
这可以通过将字典传递给python的list()构造函数list()来完成。
- d = {'id':7, 'name':'Shiba','color':'brown', 'speed':'very slow'}list(d)
- #=> ['id', 'name', 'color', 'speed']
47. 如何对字符串进行大写和小写?
可以使用upper()和lower()字符串方法。
- small_word = 'potatocake'
- big_word = 'FISHCAKE'small_word.upper()
- #=> 'POTATOCAKE'big_word.lower()
- #=> 'fishcake'
48. 将以下for循环转换为列表解析。
这个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]
列表解析通常被认为更具Python感，却仍易于阅读。
49. 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']
50. 举一个字典解析的例子。
在下面，将创建字典，以字母作为键，并以字母索引作为值。
- # 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}
51. 如何在Python中执行异常处理?
Python提供了3个单词来处理异常，请尝试使用" try"、" except"和" finally"。
句法如下所示。
- try:
- # try to do this
- except:
- # if try block fails then do this
- finally:
- # always do this
在下面的简单示例中，try块失败，因为无法在字符串中添加整数。else块设置val = 10，然后finally块打印完成。
- try:
- val = 1 + 'A'
- except:
- val = 10
- finally:
- print('complete')
- print(val)
- #=> complete
- #=> 10
52. " func"和" func()"有什么区别?
这个问题是想考查是否了解所有函数也是python中的对象。
- def func():
- print('Im a function')
- func
- #=> function __main__.func>func()
- #=> Im a function
func表示函数的对象，可以将其分配给变量或传递给另一个函数。带括号的func()调用该函数并返回其输出。
53. 解释reduce函数的工作原理
光是思考原理很难理解，需要上手几次才能明白。
reduce接受一个函数和一个序列，然后对该序列进行迭代。在每次迭代中，当前元素和前一个元素的输出都将传递给函数。最后，返回一个值。
- from functools import reducedefadd_three(x,y):
- return x + yli =[1,2,3,5]reduce(add_three, li)
- #=> 11
返回11，它是1 + 2 + 3 + 5的总和。
此列表涵盖大多数数据科学家或初级/中级python开发人员在面试中可能被问到的关python方面的问题。面试中会遇到什么问题永远不会知道，最好的准备方法是积累大量编写代码的经验。我们要做的是尽可能地准备充分。
