面试题汇总

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

 

posted @ 2018-10-15 15:23  洛水卿卿  阅读(183)  评论(0编辑  收藏  举报