测试工程师社招-python面试题

基础知识

函数

函数是可重用的程序代码块，不仅可以实现代码的复用，还能实现代码的一致性。

Python执行def时，会创建一个函数对象，绑定到函数名变量上。

在函数内部改变全局变量的值，增加global关键字声明，nolocal声明外部函数的局部变量。

a = 20
def a():
    b = 10
    def inner():
        nonlocal b  #声明外部函数的局部变量
        print(b)
        b = 30
        global a    #声明全局变量
        a = 1000
    inner()
    print(b)
a()
print(a)

Locals()打印输出的局部变量（键值对的形式）

Globals()打印输出的全局变量（键值对的形式）

局部变量的查询和访问速度比全局变量快，优先使用。

函数的参数传递本质：从实参到形参的赋值操作1、对可变对象进行写操作，直接作用于原对象本身，比如：列表、字典等，直接修改这个对象 2、对不可变对象进行写操作，产生一个新的对象空间，比如：数值、元祖、字符串等，系统会新建一个对象

深拷贝和浅拷贝：1、浅拷贝：copy.copy()不拷贝子对象的内容，只拷贝子对象的引用2、深拷贝：copy.deepcopy()子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象

import copy
def testCopy():
    '''测试浅拷贝'''
    a = [10, 20, [5, 6]]
    b = copy.copy(a)
    print("a", a)
    print("b", b)
    b.append(30)
    b[2].append(7)
    print("浅拷贝......")
    print("a", a)
    print("b", b)
def testDeepCopy():
    '''测试深拷贝'''
    a = [10, 20, [5, 6]]
    b = copy.deepcopy(a)
    print("a", a)
    print("b", b)
    b.append(30)
    b[2].append(7)
    print("深拷贝......")
    print("a", a)
    print("b", b)
testCopy()
print("*************")
testDeepCopy()

a [10, 20, [5, 6]]
b [10, 20, [5, 6]]
浅拷贝......
a [10, 20, [5, 6, 7]]
b [10, 20, [5, 6, 7], 30]
*************
a [10, 20, [5, 6]]
b [10, 20, [5, 6]]
深拷贝......
a [10, 20, [5, 6]]
b [10, 20, [5, 6, 7], 30]

传递不可变对象包含的子对象是可变的：修改可变对象，源对象会发生变化，a=(10,20,[5,6]) a[2][0] = 88 修改了源对象

参数的几种类型：1、位置参数，按照顺序传递形参实参一一对应，def f(a,b,c) f(1,2,3) 2、默认值参数，默认值参数必须位于普通参数的后面 def f1(a,b,c = 10,d = 20) f1(9,8,19) 3、命名参数，按照形参的名称传递参数，在调用的时候进行命名def f2(a,b,c) f2(c = 10,b = 20,a=22) 4、可变参数：*param，将多个参数收集到一个元祖对象中；**param，将多个参数收集到一个字典对象中 def f3(a,b,*c) f3(8,9,19,20) def f4(a,b,**d) f4(8,9,name=’zmx’,age=18) 5、强制命名参数：在可变参数后面增加新的参数，必须在调用的时候强制命名 def f5(*a,b,c) f5(2,3,4) f5(2,b = 3,c = 4)

lambda表达式和匿名函数：简单的定义函数的方法，lambda函数实际生成了一个函数对象

f = lambda a,b,c:a+b+c
print(f)
print(f(2,3,4))
#<function <lambda> at 0x01397E40>
#9
g = [lambda a:a*2,lambda b:b*3,lambda c:c*4]
print(g)  #三个函数对象
print(g[0](6),g[1](2),g[2](3))
#使用lambda函数对字典的值排序
d = {'a':4,'b':1,'c':2,'d':3}
D = sorted(d.items(),key = lambda x:x[1])
print(b）

递归函数(栈)：自己调用自己，1、终止条件，递归什么时候结束2、递归步骤，n和n-1相关联

def fun(x,n):
    if n == 0:
        return 1
    else:
        return x*fun(x,n-1)
print(fun(3,4))

字典

键值对的无序可变序列，键任意不可变，值任意数据

创建：1、{}、dict()2、zip对象 dict(zip(k,v)) 3、fromkeys创建值为空的字典 dict.fromkeys()

k = {'name','age','job'}
v = {'gaoqi',18,'teacher'}
d = dict(zip(k,v))
print(d)
a = dict.fromkeys(k)
print(a)

访问：1、通过键访问 2、get,不存在返回空，或指定对象3、items()所有的键值对，keys()所有的键，values()所有的值4、len()键值对的个数 5、检测一个键是否在字典中，”name” in dict 返回true或者false

a = {'name': 'gaoqi', 'age': 18, 'job': 'programmer'}
print(a['name'])
print(a.get('sex','nan'))   #键不存在，返回指定的对象
print(a)
print(a.items())
print(a.keys())
print(a.values())
print(len(a))  #键值对的个数

字典元素添加、修改、删除：1、新增键值对，键已存在，覆盖旧的；不存在则新增2、update()将新字典所有键值对全部添加到旧字典上，key有重复则直接覆盖 3、删除

a = {'name':'gaoqi','age':18,'job':'programmer'}
a['address'] = '111'
b = {'a':1,'b':2}
a.update(b)
print(a)
del(a['name'])
b = a.pop('age')
print(a)
print(a.popitem())#随机删除和返回该键值对

序列解包用于字典时，默认对键进行操作

s = {'name':'gaoqi','age':18,'job':'teacher'}
name,age,job = s
name,age,job = s.items()  #键值对
name,age,job = s.values()   #值
print(name)

面试题：统计一个字符串中每个字符的个数

str = 'hello,world'
dict = {}
for i in str:
    if i in dict:
        dict[i] += 1
    else:
        dict[i] =1
for i in dict:
    print(i,dict[i])

元组

不可变，不能修改元组中的元素

创建：1、() 可省略 2、tuple()

访问：1、不能修改 2、a[1] a[:4]返回的仍是元组对象 3、sorted(tuple) 元组排序，并且返回一个新的元组对象

Zip:将多个列表对应位置的元素合成元组，并返回这个zip对象

a = [10,20,30]
b = [20,30,10]
d = zip(a,b)
print(list(d))

生成器推导式创建元组：可以通过生成器对象，转化成列表或元组，也可以使用生成器的__next__()方法进行遍历，元素访问结束之后，重新访问必须重新创建该生成器对象。T = (x*2 for x in range(5)) t.__next__() tuple(s)只能访问一次，第二次就空了需要在生成一次

集合

一个无序的不重复的元素序列，用花括号{}编写

创建（1、s = set() #空集合 2、s= {} type(s) #dict 3、s = {3,4,1,4,3} #3,4,1 可以去重）

访问（集合没有顺序没有索引 无法指定位置去访问，可以遍历）(s = {'a','b','c'} for i in s:print(i)

添加、删除 s.add() s.update()参数可以是列表、元祖、字典 s.remove('a')删除不存在的会报错 s.discard('3')元素不存在不会报错 s.clear()清空 s.pop()随机删除

集合运算：s1&s2 s1|s2 交集并集差集

面试题：

集合和列表区别1、集合无序，列表有序（访问索引）2、集合元素时唯一不重复，列表元素可以重复 3、集合中的元素不可变，而列表可变 4、集合 {} 列表[]

集合和字典区别1、集合无序不重复；字典有序可重复 2、集合只能存储不可变的对象，比如数字、str、元祖等 3、集合唯一 字典可重 4、集合不索引，字典可键

面向对象

面向对象和面向过程：1、都是解决问题的思维方式，都是代码组织的方式2、解决简单问题可以使用面向过程3、解决复杂问题：宏观上使用面向对象把握，微观处理上仍是面向过程

类：通过类定义数据类型的属性和方法，对象是类的实例，一个类创建对象时，每个对象会共享这个类的行为（类中定义的方法），但是会有自己的属性值。

class Student:
    def __init__(self,name,score):
        self.name = name    #实例属性
        self.score = score
    def say_score(self):    #实例方法
        print(self.name,'的分数是：',self.score)
s = Student('zmx',20)   #s是实例对象
s.say_score()
print(dir(s))   #获得对象的所有属性和方法
print(s.__dict__)  #对象的属性字典
#isinstance(对象，类型)  判断对象是不是指定的类型

__init__()方法：初始化创建好的对象，给实例属性赋值；不定义时，系统会提供一个默认的初始化方法；__new__()方法：用于创建对象，一般无需定义该方法；

Init和new区别：1、new负责对象的创建 init负责对象的初始化2、new创建对象时调用，会返回当前对象的一个实例；init创建完对象后调用，对当前对象的一些实例初始化，无返回值

实例属性：1、init方法中定义 2、本类其他实例方法self.实例对象名访问3、创建实例对象后，通过实例对象访问 obj = 类名（）;obj.实例属性名 = 值 #给已有属性赋值，也可以添加新的属性

实例方法：1、第一个参数self 2、调用时，不需要也不能给self传参

函数和方法的区别：1、本质，都用来完成一个功能 2、方法通过对象调用 3、方法定义时需要传递self,函数不需要

类对象：执行class语句时，会创建一个类对象

类属性：从属于类对象的属性，也称为类变量

class Student:
    company = 'sss'   #类属性
    count = 0
    def __init__(self,name,score):
        self.name = name    #实例属性
        self.score = score
        Student.count = Student.count+1
    def say_score(self):
        print("我的公司是：",Student.company)
        print(self.name,'的分数是：',self.score)
s = Student('zmx',20)
s.say_score()

类方法：从属于类对象的方法，装饰器@classmethod 1、装饰器2、第一个参数cls，指的是类对象本身 3、调用格式：类名.类方法名（参数列表），参数列表中不需要也不能给cls传值

class Student:
    company = 'sss'
    @classmethod
    def printCompany(cls):
        print(cls.company)
Student.printCompany()

静态方法：与类、对象无关的方法，和普通函数没有区别，只不过静态方法放到了类里面，需要通过类调用1、@staticmethod 2、调用静态方法：类名.静态方法名（参数列表）3、访问实例属性和实例方法导致错误

class Student:
    company = 'sss'
    @staticmethod
    def add(a,b):
        print('{0}+{1}={2}'.format(a,b,(a+b)))
        return a+b
Student.add(20,30)

__del__方法（析构函数）和垃圾回收机制：用于实现对象被销毁时所需的操作，比如释放对象占用的资源；python自动垃圾回收机制，当对象没有被引用时自动调用析构方法。

__call__方法和可调用对象：定义了call方法的对象成为可调用对象，该对象可以像函数一样被调用。

Python方法没有重载：如果在类中定义多个重名的方法，只有最优一个方法有效。

方法的动态性：可以动态的为类添加新的方法，或者动态的修改类的已有方法

class Person:
    def work(self):
        print("努力上班")
def play_game(self):
    print("玩游戏")
def work2(s):
    print("好好工作，努力上班")
Person.play = play_game
Person.work = work2
p = Person()
p.play()
p.work()

私有属性和私有方法（实现封装）：1、两个下划线开头的属性是私有的private 2、类内部可以访问私有属性（方法）3、类外部不能直接访问私有属性（方法）4、类外部可以通过_类名__私有属性（方法）访问私有属性

class Employee:
    __company = "sss"  #私有类属性
    def __init__(self,name,age):
        self.name = name
        self.__age = age   #私有实例属性
    def say_company(self):
        print("我的公司是：",Employee.__company)   #类内部可以直接访问私有属性
        print(self.name,'年龄是：',self.__age)
        self.__work()
    def __work(self):   #私有实例方法
        print("工作！好好工作！")
p1 = Employee("sss",22)
print(p1.name)
print(dir(p1))
p1.say_company()
print(p1._Employee__age)  #直接访问私有属性

@property装饰器：将一个方法的调用变成属性调用，处理属性的读、写操作，做法不安全

面试题：装饰器是什么（本质是一个函数，别的函数添加装饰器可以在不修改代码的基础上添加额外的功能）

class Employee:
    @property
    def salary(self):
        return 30000
e = Employee()
print(e.salary)
print(type(e.salary))

封装：隐藏对象的属性和实现细节，只对外提供必要的方法，通过私有属性私有方法实现封装

class Employee:
    def __init__(self,name,salary):
        self.name = name
        self.__salary = salary


    @property    #相当于salary属性的getter方法
    def salary(self): 
        print("月薪为{0}，年薪{1}".format(self.__salary,12*(self.__salary)))
        return self.__salary
    @salary.setter    #相当于salary属性的setter方法
    def salary(self,salary):
        if(0<salary<1000000):
            self.__salary = salary
        else:
            print("薪水录入错误")
e = Employee("zmx",1000)
print(e.salary)
e.salary = -200

继承：定义子类时，必须在其构造函数中调用父类的构造函数

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def say_age(self):
        print(self.name,'年龄是：',self.__age)
class Student(Person):
    def __init__(self,name,age,score):
        self.score = score
        Person.__init__(self,name,age)
s = Student("zzz",12,30)
s.say_age()
print(dir(s))

1、成员继承：子类继承了父类除构造方法之外的所有成员 2、方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为重写 3、mro()或者__mro__可以输出这个类的继承层次结构 Student.mro()

class Person:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def say_age(self):
        print(self.name,'的年龄是：',self.age)
    def say_name(self):
        print("我是：",self.name)
class Student(Person):
    def __init__(self,name,age,score):
        self.score = score
        Person.__init__(self,name,age)
    def say_score(self):
        print(self.name,'的分数是：',self.score)
    def say_name(self):
        print("报告老师，我是",self.name)
s = Student("张三",17,89)
s.say_age()
s.say_score()
s.say_name()

__str__()方法，用于返回一个对于对象的描述，常用于print()方法）（把对象转换成一个字符串，一般用于print方法）

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def __str__(self):
        return "名字是{0},年龄是{1}".format(self.name,self.__age)
p = Person("zzz",20)
print(p)

Super()获得父类定义：在子类中，如果想要获得父类的方法，可以通过super()来做。

class A:
    def say(self):
        print("A:",self)
        print("AAA")
class B(A):
    def say(self):
        super().say()
        print("BBB")
b = B()
b.say()

多态：同一个方法调用由于对象不同可能会产生不同的行为1、多态是方法的多态，属性没有多态 2、两个必要条件，继承和方法重写

class Animal:
    def shout(self):
        print("动物叫了一声")
class Dog(Animal):
    def shout(self):
        print("汪汪汪")
class Cat(Animal):
    def shout(self):
        print("喵喵喵")
def animalShout(a):
    if isinstance(a,Animal):
        a.shout()
animalShout(Dog())
animalShout(Cat())

面试题

1、幂等

多次请求所产生的影响和一次请求执行的影响效果相同

调用远程服务：成功、失败、超时，超时是未知的，转账超时做好幂等控制，发起重试，保证转账正常进行，又不会多转一笔（提交表单快速点击可能产生了两条一样的数据，前端重复提交）

方案：超时了，先查一下对应的记录，如果成功，走成功的流程；如果失败按失败处理

方案二：下游接口支持幂等，上游如果超时，发起重试即可（唯一索引、数据库主键）

2、内存溢出和内存泄露

内存溢出：内存不够，通常运行大型软件或者游戏的时候，软件和游戏所需要的内存远远超出了主机所安装的内存，这就是内存溢出

内存泄露：程序申请内存后，无法释放申请的内存空间

3、进程和线程

进程：资源分配的最小单位，独立的执行环境，拥有自己的内存空间和资源

线程：程序执行的最小单位，一个进程最少一个先后才能可以多个线程同时执行，共享进程的资源（通信）

进程类比公司，线程类比员工

4、栈的应用（括号匹配、函数递归调用）

5、app闪退和崩溃

手机、包、内存、第三方库、兼容

包本身，内存问题（不足）、第三方库（没有容错机制）、兼容、设备故障

编程错误、内存问题（内存溢出、内存泄露）程序崩溃、资源不足、第三方库（youbug,不兼容）、网络问题、数据异常、设备兼容问题、硬件故障

编程题

1、时间转秒

import datetime
#使用strptime(time,格式)将t.str解析为datetime对象
def time_to_seconds(time):
    t = datetime.datetime.strptime(time,"%H:%M:%S")
    seconds = (t.hour*3600)+(t.minute*60)+t.second
    return seconds
print(time_to_seconds("10:35:40"))

2、秒转时间

import datetime
#使用datetime下的timedelta(seconds)函数将秒转换成时间，并且格式化
def seconds_to_time(seconds):
    t = datetime.timedelta(seconds=seconds)
    time = str(t)
    return time
print(seconds_to_time(5445))

3、两个时间差

import datetime
#先转格式，在计算差，在total_seconds()转换秒
def time_diff(start_time,end_time):
    t1 = datetime.datetime.strptime(start_time,"%H:%M:%S")
    t2 = datetime.datetime.strptime(end_time,"%H:%M:%S")
    diff = t2-t1
    seconds = diff.total_seconds()
    return seconds
print(time_diff("01:30:45","02:15:30"))

4、统计每个字符串个数

s = 'hello world'
dict = {}
for i in s:
    if i in dict:
        dict[i]+=1
    else:
        dict[i]=1
for i in dict:
    print(dict[i],i)

5、判断回文串

def palidrome1(s):
    n = len(s)
    for i in range(int(n/2)):
        if s[i] != s[n-i-1]:
            return False
    return True
print(palidrome1("zmxmz"))

def palidrome2(s):
    return s == s[::-1]
print(palidrome2())

7、找一个数组中最大的数

def func(alist):
    n = len(alist)
    mid_index = alist[0]
    for i in range(0,n):
        if alist[i]<=alist[mid_index]:
            i+=1
        else:
            mid_index = i
    return alist[mid_index]

alist = [2,3,4,5,6,7,10]
print(func(alist))

8、冒泡排序

def bubble_sort(a):
    n = len(a)
    for k in range(n-1):
        count = 0
        for i in range(n - 1):
            if a[i] > a[i + 1]:
                a[i], a[i + 1] = a[i + 1], a[i]
                count += 1
        if count == 0:  #判断count的值是否等于0，如果等于0说明没有交换
                break
alist = [1,2,3,4,5]
bubble_sort(alist)
print(alist)

9、插入排序

def insert_sort(a):
    n = len(a)
    for j in range(1,n):   #两部分中的第二部分，从第二个元素开始到最后一个元素
        i = j
        while i>0:      #和有序列表中每个元素进行比较（从最后一个开始）
            if a[i]<a[i-1]:
                a[i],a[i-1] = a[i-1],a[i]    #如果当前元素比前一个元素小，进行交换
            else:   #否则已经是有序序列，不需要进行交换
                break
            i -= 1
alist=[54, 226, 93, 17, 77, 31, 44, 55, 20]
insert_sort(alist)
print(alist)

10、选择排序

def select_sort(alist):
    n = len(alist)
    for i in range(n-1): #循环一次，找起始位置，最后一个不用   O（n）
        min_index = i
        for j in range(i+1,n):   #利用索引  在剩余元素中找到最小的元素    O（n）
            if alist[j] < alist[min_index]:
                min_index = j
        if min_index!=i:   #如果最小索引变了，交换元素
            alist[i],alist[min_index] = alist[min_index],alist[i]
alist = [7,5,3,6,44,22,99,11]
select_sort(alist)
print(alist)

11、快速排序

def quick_sort(alist,start,end):
    #递归退出的条件
    if start>=end:
        return
    mid  = alist[start]
    low  = start
    high = end
    while low < high:
        #由右往左   alist[high]>mid  则high-1
        while low < high and alist[high] >mid:
            high -= 1
        alist[low] = alist[high]
        #由左往右  alist[low]<mid  则low+1
        while low < high and alist[low] <mid:
            low += 1
        alist[high] = alist[low]
    #将基准数放置在对应的位置
    alist[low] = mid
    #比基准数小的即左边的数据，要重复调用quick_sort()
    quick_sort(alist,start,low-1)
    #比基准数大的即右边的数据，要重复调用quick_sort()
    quick_sort(alist,low+1,end)
alist=[54, 226, 93, 17, 77, 31, 44, 55, 20]
quick_sort(alist,0,len(alist)-1)
print(alist)

12、归并排序

def merge_sort(alist):
    if len(alist)<=1:
        return alist
    num = len(alist)//2

    left = merge_sort(alist[:num])
    right = merge_sort(alist[num:])

    return merge(left,right)
def merge(left,right):
    l,r = 0,0
    result = []
    while l<len(left) and r < len(right):
        if left[l]<right[r]:
            result.append(left[l])
            l+=1
        else:
            result.append(right[r])
            r+=1
    result += left[l:]
    result += right[r:]

    return result

alist = [54,26,77,17,44,55]
sorted_alist = merge_sort(alist)
print(sorted_alist)