53个Python经典面试题详解！

53个Python经典面试题详解！

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

• 列表是可变的。创建后可以对其进行修改。
• 元组是不可变的。元组一旦创建，就不能对其进行更改。
• 列表表示的是顺序。它们是有序序列，通常是同一类型的对象。比如说按创建日期排序的所有用户名，如[“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. formatprint( "My name is {}".format((name)))

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

• is”用来检查对象的标识(id)，而“==”用来检查两个对象是否相等。

4.什么是装饰器（decorator）？
装饰器允许通过将现有函数传递给装饰器，从而向现有函数添加一些额外的功能，该装饰器将执行现有函数的功能和添加的额外功能。

5.解释Range函数

• Range函数可以用来创建一个整数列表，一般用在for循环中。它有3种使用方法。
• Range函数可以接受1到3个参数，参数必须是整数。
  • 用法1 - range(stop)：生成从0到参数“stop”之间的整数。
  • 用法2 -range(start, stop): 生成从参数“start”到“stop”之间的整数
  • 用法3 -range(start, stop, step)：以参数“step”为步长，生成从“start”到“stop”之间的整数。

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参数，并且可以修改类本身。

8. “func”和“ func()”有什么区别？

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

9. 解释map函数的工作原理。
Map函数返回一个列表，该列表由对序列中的每个元素应用一个函数时返回的值组成。

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.解释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]

12.Python是按引用调用还是按值调用？
不可变对象（如字符串、数字和元组等）是按值调用的。可变对象（如列表等）是通过引用调用的。

13. 如何使用reverse函数反转一个列表？

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

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

'cat' * 3
#=> 'catcatcat'

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

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

16. 类中的“self”指的是什么？
“self”引用类本身的实例。这就是我们赋予方法访问权限并且能够更新方法所属对象的能力。

17. 如何在Python中连接列表？ +

List1+list2 = c
Print(c)

18. 浅拷贝和深拷贝之间有什么区别？
对于不可变的对象，浅拷贝和深拷贝的区别并不重要。

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

• Python的标准库有一个array（数组）对象，但在这里，我特指常用的Numpy数组。
• 列表存在于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可读性很强

22.你最喜欢Python的哪个库？
在处理大量数据时，没有什么比Pandas（熊猫）更有帮助了，因为Pandas让操作和可视化数据变得轻而易举。

23.举出几个可变和不可变对象的例子？
不可变意味着创建后不能修改状态。例如：int、float、bool、string和tuple。
可变意味着可以在创建后修改状态。例如列表（list）、字典（dict）和集合（set）。

24.如何分割一个列表？
分割语法使用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]

25.什么是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'}]

26.如何将一个数字四舍五入到小数点后三位？
使用round(value, decimal_places)函数。

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

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

• Dict是Python的一种数据类型，是经过索引但无序的键和值的集合。
• JSON只是一个遵循指定格式的字符串，用于传输数据。

28. 你在Python中使用了哪些ORM？

• ORM（对象关系映射）将数据模型（通常在应用程序中）映射到数据库表，并简化了数据库事务。
• SQLAlchemy通常用于Flask的上下文中，而Django拥有自己的ORM。

29. any()和all()如何工作?
Any接受一个序列，如果序列中的任何元素为true，则返回true。All只有当序列中的所有元素都为true时，才返回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.模块（module）和包（package）有什么区别？
模块是可以一起导入的文件（或文件集合）。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和break之间有什么区别?

• pass 意味着什么都不做。我们之所以通常使用它，是因为Python不允许在没有代码的情况下创建类、函数或if语句。
• Continue 会继续到下一个元素并停止当前元素的执行。
• break 会中断循环，序列不再重复下去。`

44. 如何将for循环转换为使用递推式构造列表（list comprehension）？

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()方法。

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

47.检查一个字符串是否仅仅包含字母？

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

51.举一个递推式构造字典（dictionary comprehension）的例子

# 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}

52. Python中的异常处理是如何进行的？
Python提供了3个关键字来处理异常，try、except和finally。

try: 
# try to do this
except:       
 	# if try block fails then do this
finally:     
# always do this

实例代码：

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