53道Python面试问答题,帮你成为大数据工程师!

开发 后端
不久前,我开始担任"数据科学家"的新角色,实际上是" Python工程师"。如果我提前了解Python的线程生命周期而不是推荐系统,我会做得更好。本着这种精神,这是我的python面试/工作准备问题和答案。 大多数数据科学家编写了大量代码,因此这对科学家和工程师均适用。

 数据科学家和软件工程师的Python问题

 

[[323390]]

不久前,我开始担任"数据科学家"的新角色,实际上是" Python工程师"。

如果我提前了解Python的线程生命周期而不是推荐系统,我会做得更好。

本着这种精神,这是我的python面试/工作准备问题和答案。 大多数数据科学家编写了大量代码,因此这对科学家和工程师均适用。

无论您是面试应聘者,准备应聘工作还是只是精通Python,我都认为这份清单将是无价之宝。

问题是无序的。 让我们开始。

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

在我进行过的每次python /数据科学访谈中,都曾问过我这个问题。 像手背一样知道答案。

  • 列表是可变的。 创建后可以对其进行修改。
  • 元组是不可变的。 一旦创建了元组,就不能对其进行更改
  • 列表有顺序。 它们是有序序列,通常是相同类型的对象。 即:按创建日期排序的所有用户名,[" Seth"," Ema"," Eli"]
  • 元组具有结构。 每个索引可能存在不同的数据类型。 即:内存中的数据库记录,(2," Ema"," 2020–04–16")#id,名称,created_at

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

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

 

  1. name = 'Chris' 
  2.  
  3. # 1. f strings 
  4.  
  5. print(f'Hello {name}'
  6.  
  7. # 2. % operator 
  8.  
  9. print('Hey %s %s' % (namename)) 
  10.  
  11. # 3. format 
  12.  
  13. print( "My name is {}".format((name))) 

 

3." is"和" =="有什么区别?

在我的python生涯的早期,我以为它们是相同的……您好错误。 因此,为了记录,检查身份和==检查相等性。

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

 

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

检查是否相等,并注意它们是否相等。

 

  1. print(a == b) 
  2. print(a == c) 
  3. #=> True 
  4. #=> True 

但是它们具有相同的身份吗? 不。

 

  1. print(a is b) 
  2. print(a is c) 
  3. #=> True 
  4. #=> False 

我们可以通过打印其对象ID进行验证。

 

  1. print(id(a)) 
  2. print(id(b)) 
  3. print(id(c)) 
  4. #=> 4369567560 
  5. #=> 4369567560 
  6. #=> 4369567624 

c与a和b具有不同的ID。

4.什么是装饰器?

每次面试中我都被问到另一个问题。 它本身值得发布,但是如果您可以逐步编写自己的示例,那么您已经准备好了。

装饰器允许通过将现有功能传递给装饰器,从而将功能添加到现有功能,该装饰器将执行现有功能以及其他代码。

我们将编写一个装饰器,该装饰器会在调用另一个函数时记录日志。

编写装饰器函数。 这需要一个函数func作为参数。 它还定义了一个函数log_function_drawn,该函数调用func()并执行一些代码print(f'{func}被调用。')。 然后返回定义的函数

 

  1. def logging(func):  
  2.     def log_function_called():  
  3.     print(f'{func} called.')  
  4.         func()  
  5.         return log_function_called 

让我们编写其他函数,我们最终将装饰器添加到(但尚未)。

 

  1. def my_name():  
  2.     print('chris'
  3.  
  4. def friends_name():  
  5.     print('naruto'
  6.  
  7. my_name() 
  8. friends_name() 
  9.  
  10. #=> chris 
  11. #=> naruto 

现在将装饰器添加到两者。

 

  1. @logging 
  2. def my_name():  
  3.     print('chris'
  4.  
  5. @logging 
  6. def friends_name():  
  7.     print('naruto'
  8.  
  9. my_name() 
  10. friends_name() 
  11.  
  12. #=> <function my_name at 0x10fca5a60> called. 
  13. #=> chris#=> <function friends_name at 0x10fca5f28> called. 
  14. #=> naruto 

了解现在如何仅通过在其上面添加@logging就能轻松地将日志添加到我们编写的任何函数中。

5.解释范围功能

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个属性,即"颜色"和"速度"。 然后创建一个实例并返回速度。

 

  1. class Car :  
  2.     def __init__(self, color, speed):  
  3.     self.color = color self.speed = speed 
  4.  
  5. car = Car('red','100mph'
  6. car.speed 
  7. #=> '100mph' 

7. python中的实例,静态和类方法之间有什么区别?

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

静态方法:使用@staticmethod装饰器,与特定实例无关,并且是独立的(请勿修改类或实例属性)

类方法:接受cls参数并可以修改类本身

我们将说明一个虚构的CoffeeShop类的区别。

 

  1. class CoffeeShop:  
  2.     specialty = 'espresso' 
  3.     def __init__(self, coffee_price):  
  4.     self.coffee_price = coffee_price  
  5.      
  6.     # instance method  
  7.   def make_coffee(self):  
  8.     print(f'Making {self.specialty} for ${self.coffee_price}')  
  9.      
  10.     # static method    
  11.   @staticmethod def check_weather():  
  12.     print('Its sunny')  
  13.      
  14.     # class method  
  15.   @classmethod  
  16.     def change_specialty(cls, specialty):  
  17.     cls.specialty = specialty  
  18.         print(f'Specialty changed to {specialty}'

CoffeeShop类具有特殊属性,默认情况下设置为" espresso"。 CoffeeShop的每个实例都使用属性coffee_price初始化。 它还有3种方法,实例方法,静态方法和类方法。

让我们以coffee_price为5初始化咖啡店的实例。然后调用实例方法make_coffee。

 

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

现在调用静态方法。 静态方法无法修改类或实例状态,因此通常用于实用程序功能,例如,添加两个数字。 我们用我们的天气检查天气。 大!

 

  1. coffee_shop.check_weather() 
  2. #=> Its sunny 

现在,我们使用class方法来修改咖啡店的特色菜,然后再修改make_coffee。

 

  1. coffee_shop.change_specialty('drip coffee'
  2. #=> Specialty changed to drip coffee 
  3. coffee_shop.make_coffee() 
  4. #=> Making drip coffee for $5 

请注意,make_coffee以前是用来制作意式浓缩咖啡的,但现在却可以制作滴滤咖啡!

8." func"和" func()"有什么区别?

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

 

  1. def func():  
  2.     print('Im a function')  
  3.  
  4. func 
  5. #=> function __main__.func> 
  6.  
  7. func()  
  8. #=> Im a function 

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

9.说明Map功能的工作方式

map通过将函数应用于序列中的每个元素,返回由返回值组成的列表。

 

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

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

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

将头缠起来直到您几次使用都很难。

reduce接受一个函数和一个序列,然后对该序列进行迭代。 在每次迭代中,当前元素和前一个元素的输出都将传递给函数。 最后,返回一个值。

 

  1. from functools import reduce 
  2. def add_three(x,y):  
  3.     return x + y 
  4.  
  5. li = [1,2,3,5] 
  6. reduce(add_three, li) 
  7. #=> 11 

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

11.解释filter功能如何工作

过滤器按字面意思执行。 它按顺序过滤元素。

每个元素都传递给一个函数,如果函数返回True,则按输出顺序返回;如果函数返回False,则将其丢弃。

 

  1. def add_three(x):  
  2.     if x % 2 == 0:  
  3.     return True  
  4.     elsereturn False 
  5.  
  6. li = [1,2,3,4,5,6,7,8] 
  7.  
  8. [i for i in filter(add_three, li)] 
  9. #=> [2, 4, 6, 8] 

请注意如何删除所有不能被2整除的元素。

12. python是按引用调用还是按值调用?

如果您对这个问题进行了搜索并阅读了前几页,请准备好深入了解语义。 您最好仅了解其工作原理。

不变的对象(如字符串,数字和元组)是按值调用的。 请注意,在函数内部进行修改后,name的值不会在函数外部发生变化。 name的值已分配给该功能范围内的内存中的新块。

 

  1. name = 'chr' 
  2. def add_chars(s):  
  3.     s += 'is' print(s)  
  4.  
  5. add_chars(name)  
  6. print(name
  7. #=> chris 
  8. #=> chr 

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

 

  1. li = [1,2] 
  2. def add_element(seq):  
  3.     seq.append(3)  
  4.     print(seq)  
  5.  
  6. add_element(li)  
  7. print(li) 
  8. #=> [1, 2, 3] 
  9. #=> [1, 2, 3] 

13.如何撤消清单?

请注意如何在列表上调用reverse()并对其进行突变。 它不会返回变异列表本身。

 

  1. li = ['a','b','c'
  2. print(li) 
  3. li.reverse() 
  4.  
  5. print(li) 
  6. #=> ['a''b''c'
  7. #=> ['c''b''a'

14.字符串乘法如何工作?

让我们看看将字符串" cat"乘以3的结果。

 

  1. 'cat' * 3 
  2. #=> 'catcatcat' 

该字符串将自身连接3次。

15.列表乘法如何工作?

我们来看看将列表[1,2,3]乘以2的结果。

 

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

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

16.在类上"self"指的是什么?

自我是指类本身的实例。 这就是我们赋予方法访问权限并能够更新方法所属对象的能力。

下面,将self传递给__init __()使我们能够在初始化时设置实例的颜色。

 

  1. class Shirt:  
  2.     def __init__(self, color):  
  3.     self.color = color  
  4.  
  5. s = Shirt('yellow'
  6. s.color 
  7. #=> 'yellow' 

17.如何连接python中的列表?

将2个列表加在一起将它们串联在一起。 请注意,数组的功能不同。

 

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

18.浅拷贝和深拷贝之间有什么区别?

我们将在可变对象(列表)的上下文中进行讨论。 对于不可变的物体,浅与深并不重要。

我们将介绍3种情况。

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

 

  1. li1 = [['a'],['b'],['c']] 
  2. li2 = li1 
  3. li1.append(['d']) 
  4. print(li2) 
  5. #=> [['a'], ['b'], ['c'], ['d']] 

ii)创建原始文档的浅表副本。 我们可以使用list()构造函数来做到这一点。 浅表副本会创建一个新对象,但会使用对原始对象的引用来填充它。 因此,将新对象添加到原始集合li3中不会传播到li4,但是修改li3中的一个对象将传播到li4。

 

  1. li3 = [['a'],['b'],['c']] 
  2. li4 = list(li3) 
  3. li3.append([4]) 
  4. print(li4) 
  5. #=> [['a'], ['b'], ['c']] 
  6.  
  7. li3[0][0] = ['X'
  8. print(li4) 
  9. #=> [[['X']], ['b'], ['c']] 

iii)创建一个深层副本。 这是通过copy.deepcopy()完成的。 现在,这两个对象是完全独立的,并且对其中任何一个所做的更改不会对另一个对象产生影响。

 

  1. import copy 
  2. li5 = [['a'],['b'],['c']] 
  3. li6 = copy.deepcopy(li5) 
  4. li5.append([4]) 
  5. li5[0][0] = ['X'
  6. print(li6) 
  7. #=> [['a'], ['b'], ['c']] 

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

注意:Python的标准库有一个数组对象,但在这里我专门指的是常用的Numpy数组。

  • 列表存在于python的标准库中。 数组由Numpy定义。
  • 列表可以在每个索引处填充不同类型的数据。 数组需要齐次元素。
  • 列表上的算术从列表中添加或删除元素。 每个线性代数的数组函数的算术运算。
  • 阵列还使用更少的内存,并具有更多的功能。

我写了另一篇有关数组的文章。

20.如何连接两个数组?

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

我们需要使用Numpy的连接函数来实现。

 

  1. import numpy as np 
  2. a = np.array([1,2,3]) 
  3. b = np.array([4,5,6]) 
  4. np.concatenate((a,b)) 
  5. #=> array([1, 2, 3, 4, 5, 6]) 

21.您喜欢Python的什么?

Python非常易读,并且有一种Python方式可以处理几乎所有事情,这意味着一种简洁明了的首选方式。

我将其与Ruby相比,后者通常有很多方法来做某事,而没有指南是首选。

22.您最喜欢使用Python的哪个库?

当处理大量数据时,没有什么比熊猫那么有用了,这使得操作和可视化数据变得轻而易举。

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

不可变表示创建后无法修改状态。 例如:int,float,bool,string和tuple。

可变表示状态可以在创建后进行修改。 示例是列表,字典和集合。

24.您如何将数字四舍五入到小数点后三位?

使用round(value,decimal_places)函数。

 

  1. a = 5.12345 
  2. round(a,3) 
  3. #=> 5.123 

25.您如何分割列表?

切片符号采用3个参数list [start:stop:step],其中step是返回元素的间隔。

 

  1. a = [0,1,2,3,4,5,6,7,8,9] 
  2. print(a[:2]) 
  3. #=> [0, 1] 
  4. print(a[8:]) 
  5. #=> [8, 9] 
  6. print(a[2:8]) 
  7. #=> [2, 3, 4, 5, 6, 7] 
  8. print(a[2:8:2]) 
  9. #=> [2, 4, 6] 

26.什么是pickle?

酸洗是在Python中序列化和反序列化对象的首选方法。

在下面的示例中,我们对字典列表进行序列化和反序列化。

 

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

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

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

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

28.您在Python中使用了哪些ORM?

ORM(对象关系映射)将数据模型(通常在应用程序中)映射到数据库表,并简化了数据库事务。

SQLAlchemy通常在Flask的上下文中使用,而Django拥有自己的ORM。

29. any()和all()如何工作?

Any接受一个序列,如果序列中的任何元素为true,则返回true。

仅当序列中的所有元素均为true时,All才返回true。

 

  1. a = [FalseFalseFalse
  2. b = [TrueFalseFalse
  3. c = [TrueTrueTrue
  4. print( any(a) ) 
  5. print( any(b) ) 
  6. print( any(c) ) 
  7. #=> False 
  8. #=> True 
  9. #=> True 
  10.  
  11. print( all(a) ) 
  12. print( all(b) )print( all(c) )#=> False#=> False#=> True 

30.字典或列表的查找速度更快吗?

在列表中查找值需要O(n)时间,因为整个列表需要遍历直到找到值为止。

在字典中查找键需要O(1)时间,因为它是一个哈希表。

如果值很多,这可能会造成巨大的时差,因此通常建议使用字典来提高速度。 但是它们确实还有其他限制,例如需要唯一键。

31.模块和包装之间有什么区别?

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

 

  1. import sklearn 

包是模块的目录。

 

  1. from sklearn import cross_validation 

因此,包是模块,但并非所有模块都是包。

32.如何在Python中递增和递减整数?

可以使用+-和-=进行递增和递减。

 

  1. value = 5 
  2. value += 1 
  3. print(value) 
  4. #=> 6 
  5. value -= 1 
  6. value -= 1 
  7. print(value) 
  8. #=> 4 

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

使用bin()函数。

 

  1. bin(5) 
  2. #=> '0b101' 

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

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

 

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

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

用于。

 

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

36. append和extend有什么区别?

append将值添加到列表,而extend将另一个列表中的值添加到列表。

 

  1. a = [1,2,3] 
  2. b = [1,2,3] 
  3. a.append(6) 
  4. print(a) 
  5. #=> [1, 2, 3, 6] 
  6. b.extend([4,5]) 
  7. print(b) 
  8. #=> [1, 2, 3, 4, 5] 

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

这可以通过abs()函数来完成。

 

  1. abs(2) 
  2. #=> 2 
  3. abs(-2) 
  4. #=> 2 

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

您可以使用zip函数将列表组合成一个元组列表。 这不仅限于仅使用两个列表。 也可以用3个或更多来完成。

 

  1. a = ['a','b','c'
  2. b = [1,2,3] 
  3. [(k,v) for k,v in zip(a,b)] 
  4. #=> [('a', 1), ('b', 2), ('c', 3)] 

39.如何按字母顺序对字典排序?

您无法对字典进行"排序",因为字典没有顺序,但是您可以返回已排序的元组列表,其中包含字典中的键和值。

 

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

40.一个类如何从Python中的另一个类继承?

在下面的示例中,奥迪继承自Car。 继承带来了父类的实例方法。

 

  1. class Car():  
  2.     def drive(self):  
  3.     print('vroom'
  4.  
  5. class Audi(Car):  
  6.     pass 
  7.    
  8. audi = Audi() 
  9. audi.drive() 

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

比较简单的方法是在空白处分割字符串,然后重新连接而没有空格。

 

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

42.为什么要在序列上迭代时使用enumerate()?

enumerate()允许在序列上进行迭代时跟踪索引。 它比定义和递增代表索引的整数更具Python感。

 

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

43.pass,continue和break之间有什么区别?

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

在下面的示例中,如果i> 3中没有代码,则会引发错误,因此我们使用pass。

 

  1. a = [1,2,3,4,5] 
  2. for i in a:  
  3.     if i > 3 
  4.     : pass  
  5.   print(i) 
  6.  
  7. #=> 1 
  8. #=> 2 
  9. #=> 3 
  10. #=> 4 
  11. #=> 5 

继续继续到下一个元素,并暂停当前元素的执行。 因此对于i <3的值,永远不会达到print(i)。

 

  1. for i in a:  
  2.     if i < 3:  
  3.     continue  
  4.     print(i) 
  5.  
  6. #=> 3 
  7. #=> 4 
  8. #=> 5 

break打破了循环,序列不再重复。 因此,不会打印3以后的元素。

 

  1. for i in a:  
  2.     if i == 3:  
  3.     break  
  4.     print(i)  
  5.  
  6. #=> 1 
  7. #=> 2 

44.将以下for循环转换为列表推导。

这个for循环。

 

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

成为。

 

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

列表理解通常被认为是更具Python性的,但仍易于阅读。

45.举例说明三元运算符。

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

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

 

  1. x = 5 
  2. y = 10 
  3. 'greater'  if x > 6 else 'less' 
  4. #=> 'less' 
  5.  
  6. 'greater' if y > 6 else 'less' 
  7. #=> 'greater' 

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

您可以使用isnumeric()。

 

  1. '123a'.isnumeric() 
  2. #=> False 
  3.  
  4. '123'.isnumeric() 
  5. #=> True 

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

您可以使用isalpha()。

 

  1. '123a'.isalpha() 
  2. #=> False 
  3.  
  4. 'a'.isalpha() 
  5. #=> True 

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

您可以使用isalnum()。

 

  1. '123abc...'.isalnum() 
  2. #=> False 
  3.  
  4. '123abc'.isalnum() 
  5. #=> True 

49.从字典返回键列表。

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

 

  1. d = {'id':7, 'name':'Shiba''color':'brown''speed':'very slow'
  2.  
  3. list(d) 
  4. #=> ['id''name''color''speed'

50.如何对字符串进行大写和小写?

您可以使用upper()和lower()字符串方法。

 

  1. small_word = 'potatocake' 
  2. big_word = 'FISHCAKE' 
  3.  
  4. small_word.upper() 
  5. #=> 'POTATOCAKE' 
  6. big_word.lower() 
  7. #=> 'fishcake' 

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

remove()删除第一个匹配值。

 

  1. li = ['a','b','c','d'
  2. li.remove('b'
  3.  
  4. li 
  5. #=> ['a''c''d'

del按索引删除元素。

 

  1. li = ['a','b','c','d'
  2. del li[0] 
  3.  
  4. li 
  5. #=> ['b''c''d'

pop()按索引删除一个元素并返回该元素。

 

  1. li = ['a','b','c','d'
  2. li.pop(2) 
  3. #=> 'c' 
  4.  
  5. li 
  6. #=> ['a''b''d'

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

在下面,我们将创建字典,以字母作为键,并以字母索引作为值。

 

  1. # creating a list of letters 
  2. import string 
  3. list(string.ascii_lowercase) 
  4. alphabet = list(string.ascii_lowercase) 
  5. # list comprehensiond = {val:idx for idx,val in enumerate(alphabet)}  
  6.  
  7. #=> {'a': 0, 
  8. #=> 'b': 1, 
  9. #=> 'c': 2, 
  10. #=> ... 
  11. #=> 'x': 23, 
  12. #=> 'y': 24, 
  13. #=> 'z': 25} 

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

Python提供了3个单词来处理异常,请尝试使用" except"和" finally"。

语法如下所示。

 

  1. try:  
  2. # try to do this 
  3. except:  
  4. # if try block fails then do this 
  5. finally:  
  6. # always do this 

在下面的简单示例中,try块失败,因为我们无法在字符串中添加整数。 else块设置val = 10,然后finally块打印完成。

 

  1. try:  
  2.     val = 1 + 'A' 
  3. except:  
  4.     val = 10 
  5. finally:  
  6.     print('complete')  
  7.  
  8. print(val) 
  9.  
  10. #=> complete 
  11. #=> 10 

结论

您永远不会知道面试中会遇到什么问题,最好的准备方法是拥有大量编写代码的经验。

就是说,此列表应涵盖您需要以python方式查询数据科学家或初级/中级python开发人员角色的所有内容。

我希望这对您像写对我一样对您有帮助。

我错过了什么大问题吗?

责任编辑:华轩 来源: 今日头条
相关推荐

2020-05-11 22:44:43

Python开发软件工程师

2021-02-25 11:36:28

大数据Gartner

2012-10-18 15:10:51

前端工程师面试题WEB开发

2015-02-03 03:05:02

LinuxLinux命令

2018-06-28 09:34:26

架构师Python面试题

2018-03-02 09:10:51

2010-04-15 09:53:47

Oracle笔试题

2017-11-09 14:12:44

大数据软件工程师算法工程师

2021-03-24 15:15:34

数据工程师开发工具

2024-02-26 15:35:44

2018-04-16 12:38:37

大数据工程师面试

2015-08-04 13:50:35

Linux防火墙iptables

2021-03-23 10:04:55

数据工程师工具数据分析

2020-01-17 13:33:42

大数据分析师大数据工程师

2021-01-29 17:26:03

大数据开发工程师

2012-10-24 11:13:49

开发技术周刊

2020-03-17 15:15:49

Python工程师面试题

2023-04-18 10:05:20

系统框架

2020-07-06 13:21:50

大数据安全技术

2020-08-05 08:25:58

大数据Java技术
点赞
收藏

51CTO技术栈公众号