阿里招聘Python工程师最新面试专题2021-03-13

阿里招聘Python工程师最新面试专题

单例模式与工厂模式

单例模式：主要目的是确保某一个类只有一个实例存在。

工厂模式：包涵一个超类，这个超类提供一个抽象化的接口
来创建一个特定类型的对象，而不是决定哪个对象可以被创建。

类中的各种函数

主要分为实例方法、类方法和静态方法

实例方法：

定义：第一个参数必须是实例对象，该参数名一般约定为“self”，     
通过它来传递实例的属性和方法（也可以传类的属性和方法）；

调用：只能由实例对象调用。

类方法：

定义：使用装饰器@classmethod。第一个参数必须是当前类对象，  
      该参数名一般约定为“cls”，通过它来传递类的属性和方法
      （不能传实例的属性和方法）；

调用：实例对象和类对象都可以调用。

静态方法：

定义：使用装饰器@staticmethod。参数随意，没有
“self”和“cls”参数，但是方法体中不能使用类或实例的
任何属性和方法；

调用：实例对象和类对象都可以调用。

什么是lambda函数？

Python允许你定义一种单行的小函数。定义lambda函数的
形式如下：labmda 参数：表达式lambda函数默认返回表达式的值。
你也可以将其赋值给一个变量。lambda函数可以接受任意个参数，
包括可选参数，但是表达式只有一个：

g = lambda x, y: x*y
g(3,4)
12

g = lambda x, y=0, z=0: x+y+z
g(1)
1

g(3, 4, 7)
14

也能够直接使用lambda函数，不把它赋值给变量：

(lambda x,y=0,z=0:x+y+z)(3,5,6)
14

如果你的函数非常简单，只有一个表达式，不包含命令，可以考虑lambda函数。否则，你还是定义函数才对，毕竟函数没有这么多限制。

Python是如何进行内存管理的？

Python的内存管理是由Python得解释器负责的，开发人员可以
从内存管理事务中解放出来，致力于应用程序的开发，这样就
使得开发的程序错误更少，程序更健壮，开发周期更短

Python里面如何实现tuple和list的转换？

函数tuple(seq)可以把所有可迭代的(iterable)序列转换成一个
tuple, 元素不变，排序也不变。
例如，tuple([1,2,3])返回(1,2,3), tuple(’abc’)返回(’a’.’b',’c').如
果参数已经是一个tuple的话，函数不做任何拷贝而直接返回原
来的对象，所以在不确定对象是不是tuple的时候来调用tuple()
函数也不是很耗费的。

函数list(seq)可以把所有的序列和可迭代的对象转换成一个list,
元素不变，排序也不变。
例如 list([1,2,3])返回(1,2,3), list(’abc’)返回['a', 'b', 'c']。如果参
数是一个list, 她会像set[:]一样做一个拷贝

写出一段Python代码实现删除一个list里面的重复元素

可以先把list重新排序，然后从list的最后开始扫描，
代码如下：

if List:
List.sort()
last = List[-1]
for i in range(len(List)-2, -1, -1):
if last==List[i]: del List[i]
else: last=List[i]

Python文件操作的面试题

如何用Python删除一个文件？
使用os.remove(filename)或者os.unlink(filename);
Python如何copy一个文件？
shutil模块有一个copyfile函数可以实现文件拷贝

如何用Python来发送邮件？

可以使用smtplib标准库。
以下代码可以在支持SMTP监听器的服务器上执行。
import sys, smtplib
fromaddr = raw_input(”From: “)
toaddrs = raw_input(”To: “).split(’,')
print “Enter message, end with ^D:”
msg = ”
while 1:
line = sys.stdin.readline()
if not line:
break
msg = msg + line

发送邮件部分

server = smtplib.SMTP(’localhost’)
server.sendmail(fromaddr, toaddrs, msg)
server.quit()

有两个序列a,b，大小都为n,序列元素的值任意整形数

无序；要求：通过交换a,b中的元素，使[序列a元素的和]与[序列
b元素的和]之间的差最小。将两序列合并为一个序列，并排序，
为序列Source拿出最大元素Big，次大的元素Small在余下的序列
S[:-2]进行平分，得到序列max，min将Small加到max序列，将Big
加大min序列，重新计算新序列和，和大的为max，小的为min。

Python代码：

def mean( sorted_list ):
if not sorted_list:
return (([],[]))
big = sorted_list[-1]
small = sorted_list[-2]
big_list, small_list = mean(sorted_list[:-2])
big_list.append(small)
small_list.append(big)
big_list_sum = sum(big_list)
small_list_sum = sum(small_list)
if big_list_sum > small_list_sum:
return ( (big_list, small_list))
else:
return (( small_list, big_list))
tests = [   [1,2,3,4,5,6,700,800],
[10001,10000,100,90,50,1],
range(1, 11),
[12312, 12311, 232, 210, 30, 29, 3, 2, 1, 1]
]
for l in tests:
l.sort()
print
print “Source List:    ”, l
l1,l2 = mean(l)
print “Result List:    ”, l1, l2
print “Distance:    ”, abs(sum(l1)-sum(l2))
print ‘-*’*40

输出结果

Source List:    [1, 2, 3, 4, 5, 6, 700, 800]
Result List:    [1, 4, 5, 800] [2, 3, 6, 700]
Distance:       99
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Source List:    [1, 50, 90, 100, 10000, 10001]
Result List:    [50, 90, 10000] [1, 100, 10001]
Distance:       38
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Source List:    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Result List:    [2, 3, 6, 7, 10] [1, 4, 5, 8, 9]
Distance:       1
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
Source List:    [1, 1, 2, 3, 29, 30, 210, 232, 12311, 12312]
Result List:    [1, 3, 29, 232, 12311] [1, 2, 30, 210, 12312]
Distance:       21
-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*