面试题汇总

1. 用一行转换a,b的值

a=1
b=2
a,b=b,a
print(a,b)

内存里存两个东西，一个是1和2的内存地址，一个是名称空间，名称空间存的是变量与值的对应关系

对应关系存的是a这个变量指向的是哪个内存地址，通过内存地址找到内容

a,b=b,a改变了对应关系

2. 判断类型

u1 = (1)
tu2 = (1,)
print(tu1,type(tu1))
print(tu2,type(tu2))


tu1 = ([1])
tu2 = ([1],)
print(tu1,type(tu1))
print(tu2,type(tu2))

元组  如果元组里面只有一个元素且不加逗号，那此元素是什么类型就是什么类型

3. 去重

li=[1,2,33,33,2,1,4,5,6,6]
set1=set(li)
print(set1)
li=list(set1)
print(li)

4. 深浅拷贝

 1. 赋值运算

l1 = [1,2,3,['barry','alex']]
l2 = l1

l1[0] = 111
print(l1)  # [111, 2, 3, ['barry', 'alex']]
print(l2)  # [111, 2, 3, ['barry', 'alex']]

l1[3][0] = 'wusir'
print(l1)  # [111, 2, 3, ['wusir', 'alex']]
print(l2)  # [111, 2, 3, ['wusir', 'alex']]

赋值运算来说，l1和l2指向同一个内存地址，所以他们是完全一样

2. 浅拷贝

l1 = [1,2,3,['barry','alex']]
l2 = l1.copy()

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2380296895816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2380296895048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2593038941128
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2593038941896
         
l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016
print(l2,id(l2[3]))  # [1, 2, 3, ['wusir', 'alex']] 1732315659016

浅拷贝来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性
列表里面套列表，第一层指向共同的内存，第二层指向不同内存

3. 深拷贝

import copy
l1 = [1,2,3,['barry','alex']]
l2 = copy.deepcopy(l1)

print(l1,id(l1))  # [1, 2, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[1] = 222
print(l1,id(l1))  # [1, 222, 3, ['barry', 'alex']] 2915377167816
print(l2,id(l2))  # [1, 2, 3, ['barry', 'alex']] 2915377167048

l1[3][0] = 'wusir'
print(l1,id(l1[3]))  # [1, 222, 3, ['wusir', 'alex']] 2915377167240
print(l2,id(l2[3]))  # [1, 2, 3, ['barry', 'alex']] 2915377167304

深拷贝：列表里套列表，两个分别指向不同的内存地址
对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。

deepcopy(): 深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。
copy(): 浅复制,并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。这就和我们寻常意义上的复制有所不同了。
                        对于简单的 object，用 shallow copy 和 deep copy 没区别

5. 生成器面试题

def demo():
    for i in range(4):
        yield i

g=demo()

g1=(i for i in g)
g2=(i for i in g1)

print(list(g1))   #[0,1,2,3]
print(list(g2))   #[]

def add(n,i):
    return n+i

def test():
    for i in range(4):
        yield i

g=test()
for n in [1,10]:
    g=(add(n,i) for i in g)

print(list(g))

6. 匿名函数面试题

1. 下面程序的输出结果是：

d = lambda p:p*2
t = lambda p:p*3
x = 2
x = d(x)
x = t(x)
x = d(x)
print x

2. 现有两元组(('a'),('b')),(('c'),('d')),请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]

ret=zip(('a'),('b')),(('c'),('d')))
#def func(tup):
#    return {tup[0]:tup[1]}
res=map(lambda tup:{tup[0]:tup[1]},ret)
print(list(res))

3.以下代码的输出是什么？请给出答案并解释。

def multipliers():

    return [lambda x:i*x for i in range(4)]

print([m(2) for m in multipliers()])

请修改multipliers的定义来产生期望的结果。

结果：[6,6,6,6]

def multipliers():

      return (lambda x:i*x for i in range(4))

print([m(2) for m in multipliers()])

结果：[0,2,4,6]

7. super函数的本质

求输出字母的顺序

class A:
    def func(self):
        print('A')
class B(A):
    def func(self):
        super().func()
        print('B')
class C(A):
    def func(self):
        super().func()
        print('C')
class D(B,C):
    def func(self):
        super().func()
        print('D')
d=D()
d.func()

8. 根据姓名和性别相同，筛除重复项

class Person:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex

    def __hash__(self):
        return hash(self.name+self.sex)

    def __eq__(self, other):
        if self.name == other.name and self.sex == other.sex:return True


p_lst = []
for i in range(4):
    p_lst.append(Person('egon',i,'male'))

print(p_lst)
print(set(p_lst))

注意：set依赖对象的hash、eq