软件工程师的试炼之地:53道Python面试问答

开发 后端
我整理了python面试或准备求职用的问题和答案。大多数数据科学家会编写大量代码,因此这均适用于数据科学家和软件工程师。

本文转载自公众号“读芯术”(ID:AI_Discovery)

不久前我才通过面试,入职成为了“数据科学家”,但我实际上做的却是“Python工程师”的工作。如果能提前复习Python线程生命周期的知识,而不是推荐系统,我可以准备得更好。

出于这种想法,我整理了python面试或准备求职用的问题和答案。大多数数据科学家会编写大量代码,因此这均适用于数据科学家和软件工程师。

无论你是准备面试抑或是复习Python知识,这份清单都将能够帮到你。

问题不分先后,我们开始吧!

[[325689]]

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

每次python或数据科学面试中,我都被问到过这个问题。求职者应对这个答案了如指掌。

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

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

在我初学python时,我以为它们是相同的……却出现了一些bug。因此,为了记录,is表示检查身份,而==表示检查相等性。

可通过一个例子来解释。创建一些列表并将其分配给名称。请注意,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。

3. 什么是装饰器?

这个问题每次面试都会问到。问题本身值得再写一篇文章,但是如果可以逐步编写自己的示例,那么就已经准备好回答这个问题了。

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

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

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

  1. deflogging(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')def friends_name(): 
  3.   print('naruto')my_name() 
  4. friends_name() 
  5. #=> chris 
  6. #=> naruto 

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

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

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

4. 如何实现字符串插值?

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

  1. name = 'Chris'# 1. f strings 
  2. print(f'Hello {name}')# 2. % operator 
  3. print('Hey %s %s' % (name, name))# 3. format 
  4. print( 
  5.  "My name is {}".format((name)) 

5. 解释range函数

Range生成一个整数列表,有3种使用方式。

该函数接受1到3个参数。请注意,将每种用法都包装在列表解析中,以便看到生成的值。

range(stop):生成从0到"stop"整数的整数。

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

range(start,stop):生成从" start"到" stop"整数的整数。

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

range(start,stop,step):以" step"为间隔生成从" start"到" stop"的整数。

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

6.定义一个名为car的类,具有2个属性,即"颜色"和"速度"。然后创建一个实例并返回速度。

  1. class Car : 
  2.     def __init__(self, color, speed): 
  3.         self.color = color 
  4.         self.speed = speedcar =Car('red','100mph') 
  5. car.speed 
  6. #=> '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.       # instance method 
  6.     def make_coffee(self): 
  7.         print(f'Making {self.specialty}for ${self.coffee_price}') 
  8.        # static method    
  9.     @staticmethod 
  10.     def check_weather(): 
  11.         print('Its sunny')    # class method 
  12.     @classmethod 
  13.     def change_specialty(cls, specialty): 
  14.         cls.specialty = specialty 
  15.         print(f'Specialty changed to{specialty}') 

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

[[325690]]

图源:unsplash

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

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

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

  1. coffee_shop.check_weather() 
  2. #=> Itssunny 

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

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

请注意,make_coffee以前是用来制作espresso 的,但现在却可以制作drip coffee!

8. 解释filter函数的运行原理

顾名思义,Filter函数的运行原理是按顺序过滤元素。

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

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

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

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

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

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

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

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

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

10. 如何撤消列表?

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

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

11. 说明map函数的工作原理

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

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

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

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

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

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

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

13. 列表乘法如何工作?

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

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

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

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

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

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

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

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

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

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

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

在可变对象(列表)的情境下进行讨论。对于不可变对象,浅与深并不重要。

这里介绍3种情况。

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

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

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

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

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

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

17. 如何连接两个数组?

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

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

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

18. 喜欢Python的原因?

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

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

 

[[325691]]

 

 

图源:unsplash

 

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

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

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

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

可变表示状态在创建后可以进行修改。比如列表、字典和集合。

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

使用round(value,decimal_places)函数。

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

22. 如何分割列表?

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

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

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

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

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

有关数组的知识值得再写一篇文章。

24. 什么是pickling?

picking是在Python中序列化和反序列化对象的协助方法。

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

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

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

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

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

26. 在Python中使用了哪些ORM?

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

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

  1. ['c', 'b', 'a'] 

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

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

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

  1. a = [False, False, False] 
  2. b = [True, False, False] 
  3. c = [True, True, True]print( any(a) ) 
  4. print( any(b) ) 
  5. print( any(c) ) 
  6. #=> False 
  7. #=> True 
  8. #=> Trueprint( all(a) ) 
  9. print( all(b) ) 
  10. print( all(c) ) 
  11. #=> False 
  12. #=> False 
  13. #=> True 

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

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

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

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

 

[[325692]]

 

 

图源:unsplash

 

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

使用bin()函数。

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

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

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

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

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

使用in。

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

32. append和extend有什么区别?

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

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

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

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

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

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

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

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

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

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

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

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

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

  1. class Car(): 
  2.     def drive(self): 
  3.         print('vroom')class Audi(Car): 
  4.     passaudi = Audi() 
  5. audi.drive() 

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

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

  1. importsklearn 

包是模块的目录。

  1. from sklearnimport cross_validation 

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

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

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

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

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

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

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

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

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

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

41. pass、continue和break之间有什么区别?

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

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

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

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

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

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

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

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

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

句法看起来像a if condition else b.。

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

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

可以使用isnumeric().

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

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

可以使用isalpha().

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

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

您可以使用isalnum().

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

46. 从字典返回键列表。

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

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

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

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

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

48. 将以下for循环转换为列表解析。

这个for循环。

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

成为:

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

列表解析通常被认为更具Python感,却仍易于阅读。

 

软件工程师的试炼之地:53道Python面试问答

 

 

图源:unsplash

 

49. remove、del和pop有什么区别?

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

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

del按索引删除元素。

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

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

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

50. 举一个字典解析的例子。

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

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

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

Python提供了3个单词来处理异常,请尝试使用" try"、" 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.    print(val) 
  8. #=> complete 
  9. #=> 10 

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

这个问题是想考查是否了解所有函数也是python中的对象。

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

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

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

光是思考原理很难理解,需要上手几次才能明白。

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

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

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

 

[[325693]]

 

 

图源:unsplash

 

此列表涵盖大多数数据科学家或初级/中级python开发人员在面试中可能被问到的关python方面的问题。面试中会遇到什么问题永远不会知道,最好的准备方法是积累大量编写代码的经验。我们要做的是尽可能地准备充分。

 

责任编辑:赵宁宁 来源: 读芯术
相关推荐

2020-04-23 10:27:20

Python数据工程师

2009-06-29 10:58:08

软件工程师求职者

2016-02-18 10:18:34

Java工程师面试考纲

2020-09-17 16:11:04

软件开发 技术

2012-10-18 15:10:51

前端工程师面试题WEB开发

2022-07-29 09:12:44

软件硬件开发

2013-09-18 14:38:06

面试

2013-09-03 09:30:44

软件工程师软件工程师头衔

2022-09-16 08:00:00

软件工程师求职薪酬

2022-01-16 07:12:30

软件工程师吵架开发

2009-02-11 13:15:54

软件工程师女工程师google

2009-03-11 11:02:19

面试软件工程师软件开发

2023-06-05 10:07:13

软件工程平台工程师

2009-02-27 10:34:13

2015-06-02 11:29:55

软件工程师程序员

2010-08-10 13:22:41

2009-02-12 11:52:23

软件工程师职业规划价值

2017-11-09 14:12:44

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

2018-01-09 17:21:18

软件工程师创业代码

2015-06-02 04:08:42

软件工程师私活
点赞
收藏

51CTO技术栈公众号