四面阿里，已拿意向书，准备了python测开面试总结

本文分享给需要面试的朋友，也祝愿大家顺利拿到自己想要的offer，整理了一些python的资料，自动化测试、功能测试、接口测试以及大厂面试题等等。有需要的话： 戳这里！这里！，暗号： CSDN。

1.解释型语言和编译型语言区别：

计算机不能直接理解高级语言，需要把高级语言翻译成机器语言。翻译的方式有两种，一种是编译，一种是解释。

编译过后，会生成计算机能够直接运行的文件。

解释性语言虽然省略了编译，每次运行都需要重新解释一遍，所以运行效率更低。

2.面向对象和面向过程的区别

面向过程：是解决问题步骤性导向，一步一步解决问题。

优点：流程化使得编程任务明确，在开发前基本考虑了实现方式和最终结果。

缺点：需要深入思考，耗费精力，代码重用性低，扩展能力差，维护起来难度比较高。

面向对象：功能性为导向，根据不同的功能来实现不同的对象。

优点：结构清晰，程序便于模块化，结构化，抽象化，更符合人类思维方式。

封装性，将事务高度抽象，从而便于流程中的行为分析，便于操作和自省。

容易扩展，代码重用率高，科技城，可覆盖。

实现简单，可有效减少程序维护工作。

3.面向对象行间的考察点三个基本特征：封装、继承、多态

封装：

继承：

super():

在重写父类方法时，若需要调用父类方法可用。

super(子类，self).方法名（）

多态：

作用：让具有不同功能的函数可以使用相同的函数名，这样可以用一个函数名调用不同内容的函数。

特点：

1.只关心实例方法是否同名，不关心是否属于同一类。

2.对象所属的类，继承关系可有可无。

3.可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；

4.多态是调用方法的技巧，不会影响到类的内部设计。

装饰器

相当于一个嵌套函数，装饰器以函数为参数

case1

# 调用函数前打印函数名字
def log(func):
    def wrapper(*args,**kw):   
    print('call %s'%func__name__)
    return func(*args,**kw)
return wrapper
 
@log
def now():
    print('hello,world')
 
# 相当于执行了log(now)
now()
 
>>>call now
hello,world

case2

#当装饰器中需要传入参数时：
def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator
 
@log('call')
def no():
    print('hello,world.')
 
if __name__=='__main__':
    no()
    print(no.__name__)  # 由于调用返回的为wraper,所以函数的名字为wraper

@classmethod修饰符

classmethod修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以调用类的属性，类的方法，实例化对象等。

class A(object):
    bar=1 #类属性
    def func1(self):
        print('')
    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()
A.func2() # 不需要实例化

@staticmethod

返回函数的静态方法。

该方法不强制要求传递参数。

class C(object):
    @staticmethod
    def f():
        print('runoob')
C.f()  # 可以不用实例化调用
C.().f() # 也可以实例化调用

@proerty

作用：把方法变成属性的调用。

深拷贝、浅拷贝、等号赋值

深拷贝：新建一个对象，把原来的内存里的内容完全复制过来，改变复制对象，不会改变原内存的内容。

浅拷贝：两种情况

1.浅拷贝的值是不可变对象（数组、字符、元组）时，和等于复制一样，对象的id值和浅拷贝原来的值相同；

2.如果对象时可变：a.一个简单的没有嵌套的对象，复制前后相互之间不影响，
b.对象中有复杂子对象，如列表嵌套，如果改变原来的对象中复杂子对象的值，浅拷贝的值也会受影响，因为在浅拷贝时只复制了子对象的引用。

import copy
x = [[1,2],[2,3],4]
a = copy.copy(x)
print(a is x)   #False
print(a[0] is x[0]) # True

以上这些就是相关总结，希望能帮到大家吧~

走过路过点个赞~