Python面试重点（基础篇）

Python面试重点（基础篇）

注意：只有必答题部分计算分值，补充题不计算分值。

第一部分 必答题（每题2分）

1. 简述列举了解的编程语言及语言间的区别？

   python简单，python开发效率快，python代码简介，python跨平台，python学习成本比较低
   

2. 列举Python2和Python3的区别？

   python2: print、ascii、类：金典类，新式类、range（）:  列表、xrange（）: 可迭代对象、raw_input（）: 获取的内容全都是字符串、input()  “alex”、除法: 整数、xreadlines : 返回一个迭代器
   

   python3: print()、unicode、类：新式类、range（）  :  可迭代对象、input() : 获取的内容全都是字符串、除法: 浮点数、readlines（）: 列表、没有long（长整型）
   

3. 看代码写结果

   v1 = 1 or 2
   v2 = 3 and 7 or 9 and 0  
   

   • or，左边为真记左边
   • and，右边为真记右边

4. 比较以下值有什么不同？

   v1 = [1,2,3]
   v2 = [(1),(2),(3)]
   v3 = [(1,),(2,),(3,)]
   

   • v1与v2为列表，v3为列表中有元组

5. 用一行代码实现数值交换。

   a = 1   
   b = 2
   

   • a,b = b,a

6. Python中单引号、双引号、三引号的区别？

   单双引号都可以在括号内使用(" '内容' ")
   三引号可以显示多行,注释
   

7. is和==的区别？

   is 判断两边的内存地址是否相等
   == 判断等号两边的值是否相等
   

8. python里如何实现tuple和list的转化？

   list=[1,2,3,4,5,6]
   x=tuple(list)
   print(type(x),x)
   
   
   tup=(1,2,3,4,5,6)
   y=list(tup)
   print(type(y),y)
   

9. 如何实现字符串 name='老男孩'的反转？

   使用字符串切片 name1=name[::-1]
   

10. 两个set如何获取交集、并集、差集？

    a=set('asdfg')
    b=set('qwert')
    交集:
    print(x&y)
    并集:
    print(x|y)
    差集:
    print(x-y)
    

11. 那些情况下, y != x - (x-y)会成立?

    x和y是两个不相等的非空集合，也不能是x的子集
    

12. Python中如何拷贝一个对象？

    可以使用浅拷贝拷贝父对象,也可以copy模块的deepcopy完全拷贝父对象和子对象
    

13. 简述 赋值、浅拷贝、深拷贝的区别？

    赋值是将多个变量指向同一个内存地址
    浅拷贝是只拷贝第一层元素的地址
    深拷贝是完全拷贝原来的对象,拷贝后的对象是新的对象
    

14. pass的作用？

    定义一个空类
    保证程序结构的完整
    

15. 阅读代码写结果。

    import copy
    a = [1,2,4,5,['b','c']]
    b = a
    c = copy.copy(a)
    d = copy.deepcopy(a)
    
    a.append(5)
    a[4].append('d')
    
    print(b)
    print(c)
    print(a)
    

    • [1,2,4,5,['b','c','d'],5]
    • [1,2,4,5,['b','c','d']]
    • [1,2,4,5,['b','c','d'],5]

16. 用Python实现9 * 9 乘法表。

    for i in range(1, 10):
        str_obj = ''
        for j in range(1, i+1):
            obj = '{}*{}={} '.format(i, j, i * j)
            str_obj += obj
        print(str_obj)
    

17. 用Python显示一个斐波那契数列。

    li = [0, 1]
    
    for i in range(10-2):
        li.append(li[-1] + li[-2])
    print(li)
    
    
    a,b=0,1
    for i in range(10-2):
        print(a)
        a,b = b,a+b
    

18. 如何删除列表中重复的值？

    list1=["1","1","2","3"]
    print(list(set(list1)))
    在列表中元素值少的情况下,可以直接用索引删除指定重复的值
    

19. 一个大小为100G的文件etl_log.txt, 要读取文件中的内容, 写出具体过程代码？

20. a = dict(zip(("a","b","c","d","e"),(1,2,3,4,5))) 请问a是什么？

    {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
    
    a = dict(zip(("a","b","c","d","e"),(1,2,3,4,5,6)))
    print(a)
    也同样输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
    

21. lambda关键字的作用？

22. *arg和**kwarg作用?

    *args : 接收多余位置参数,以元组的形式显示, 可以修改名字,但是不建议修改
    **kwargs: 接收多余关键字参数,以字典的形式显示
    

23. 如何在函数中设置一个全局变量 ?

    global
    

24. filter、map、reduce的作用？

    lst = [1,2,3,4,5,6,7,8,9]
    def func(x):
        return x > 5
    
    print(list(filter(func,lst)))   # 高阶函数 -- 帮咱们实现了一个for循环
    
    模拟filter
    def foo(x):
        """指定过滤的规则"""
        return x > 5
    
    def f(func,iter):
        lst = []
        for i in iter:
            if func(i):
                lst.append(i)
        return lst
    
    print(f(foo,[1,2,3,4,5,6,7,8,9]))
    
    print(list(map(str,[3,4,5,5,6,7])))   # 映射
    
    from functools import reduce
    print(reduce(lambda x,y:x+y,[1,2,3,4,5]))
    

25. 什么是匿名函数？匿名函数有什么作用？

    一行函数
    减少不必要的函数暴露，提高代码的可读性
    

26. Python递归的最大层数？

    官方:1000，实际998
    

27. 什么是迭代器？什么是可迭代对象？

    迭代器: 具有__iter__和__next__的就是迭代器
    可迭代对象: 具有__iter__方法的就是可迭代对象
    

28. 什么是生成器？

    生成器的本质的就是迭代器,函数体出现yield就是生成器
    

29. 区分生成器和迭代器:

    1.通过内存地址
    2.通过send()方法
    

30. 什么是装饰器及应用场景？

    装饰器本质上是⼀个python函数，它可以在让其他函数在不需要做任何代码的变动的前提下增加额外的功能；
    应用场景:
    计算函数运行次数；
    插入日志，作为函数的运行日志；
    缓存，实现缓存处理；
    

31. 什么是反射及应用场景？

    通过字符创操作对象的属性和方法
    

32. 写一个普通的装饰器。

    def warpper(f):
        def inner(*args,**kwargs):
            print("被装饰函数执行前")
            ret = f(*args,**kwargs)
            print("被装饰函数执行后")
            return ret
        return inner
    def func(*args,**kwargs):
        print(f"被装饰的{args,kwargs}")
        return "这是func函数"
    func = warpper(func)
    print(func(1,2,3,a=1))
    

33. 写一个带参数的装饰器。

    def auth(argv):--接收参数
        def warpper(func):
            def inner(*args,**kwargs):
                if argv == '博客园':
                    print('欢迎登陆博客园')
                    user = input(userse)
                    pwd = input('pwd')
                    if user =='alex' and pwd =='ds12':
                        func(*args,**kwargs)
                 elif argv == '码云':
                    print('欢迎登陆码云')
                    user = input(userse)
                     pwd = input('pwd')
                     if user =='ale' and pwd =='ds23': 
                        func(*args,**kwargs)
            return inner
        return warpper
    
    def foo():
        print('被装饰的函数')
    a = auth("111")
    foo = a(foo)
    foo()
    

34. 求结果

    def num():
      return [lambda x:i*x for i in range(4)]
    print([m(2) for m in num()])
    
    

    • [6,6,6,6]

35. def(a, b=[])这种写法有什么陷阱？

    def func(a,b=[]):
        b.append(a)
        return b
    
    l1 = func(1)
    l2 = func(2,[11,22])
    l3 = func(3)
    
    
    print(l1,l2,l3)
    #执行结果： [1,3]   [11,22,2]   [1,3]
    函数的第二个默认参数是一个list，当第一次执行的时候实例化了一个list，第三次执行还是用第一次执行的时候实例化的地址存储，所以第一和第三次执行的结果就是相同的，想每次执行只输出当前传入参数 ，默认参数应该设置为None。
    
    下面这种情况：
    
    def func(a,b=[]):
    　　b.append(a)
    　　print(b)
    
    func(1)
    func(2,[11,22,33])
    func(3)
    
    #执行结果： [1] [11,22,33,2] [1,3] ###此时每个func函数是立即打印所以会出现不同结果
    

36. 看代码写结果

    def func(a,b=[]):
        b.append(a)
        return b
    
    v1 = func(1)
    v2 = func(2,[10,20])
    v3 = func(3)
    print(v1,v2,v3)
    结果:[1, 3] [10, 20, 2] [1, 3]
    

37. 看代码写结果

    def func(a,b=[]):
        b.append(a)
        return b
    
    v1 = func(1)
    print(v1)
    v2 = func(2,[10,20])
    print(v2)
    v3 = func(3)
    print(v3)
    结果:
    

38. 请编写一个函数实现将IP地址转换成一个整数。

    如 10.3.9.12 转换规则为：
            10            00001010
             3            00000011
             9            00001001
            12            00001100
            
    再将以上二进制拼接起来计算十进制结果：00001010 00000011 00001001 00001100 = ?
    
    
    ip = "10.3.9.12"
    s = ""
    for i in ip.split("."):
        s += format(int(i),"08b")
    print(int(s,2))
    
    ip = "10.3.9.12"
    import socket,struct
    print(struct.unpack("!I",socket.inet_aton(ip))[0])
    

39. 请查找一个目录下的所有文件（可能存在文件嵌套）。

40. 求结果

    import math   # 数学
    print(math.floor(5.9))  # 地板  向下取整
    print(math.ceil(4.1))     # 天花板 向上取整
    

41. 是否使用过functools中的函数？其作用是什么？

    生成一个固定参数的新函数
    

42. re的match和search区别？

    match()只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回none
    search()会扫描整个字符串并返回第一个成功的匹配：
    

43. 用Python匹配HTML tag的时候,<.>和<.?>有什么区别?

    <.*>尽可能多的匹配，就是匹配到的字符串尽量长，<.*?>是尽可能少的匹配，就是匹配到的字符串尽量短。
    

44. 如何生成一个随机数？

    import random
     
    print(random.randint(0,9))
    

45. super的作用？

    可以在子类中调用父类的方法或属性
    

46. 双下划线和单下划线的区别？

    __name是私有变量,只有内部可以访问,外部访问不了
    _name是"可以被访问,但是是私有变量"
    

47. @staticmethod和@classmethod的区别？

    @staticmethod不需要表示自身对象的self和自身类的参数而@classmethod也不需要self参数，但第一个参数需要是表示自身类的参数
    

48. 实现一个单例模式（加锁）。

49. 栈和队列的区别？

    队列先进先出
    栈后进先出
    

50. 以下代码输出是什么? 请给出答案并解释。

    class Parent(object):
        x = 1
    
    class Child1(Parent):
        pass
    
    class Child2(Parent):
        pass
    
    print Parent.x, Child1.x, Child2.x
    
    Child1.x = 2
    print Parent.x, Child1.x, Child2.x
    
    Parent.x = 3
    print Parent.x, Child1.x, Child2.x
    

51. 参考下面代码片段

    class Context:
        pass
    
    with Content() as ctx:
        ctx.do_something()
    请在Context类下添加代码完成该类的实现
    class Sample:
        def __enter__(self):
            return self
    
        def __exit__(self, type, value, trace):
            print("type:", type)
            print("value:", value)
            print("trace:", trace)
            print(sample)
    
    
        def do_something(self):
            bar = 1
            return bar + 10
    
    with Sample() as sample:
        sample.do_something()
    

52. 多装饰器条件下执行步骤

    def wrapper(func):
     def inner(*args,**kwargs):
         print("is 123")
         func(*args,**kwargs)
         print("345")
     return inner
    def wrapper1(func):
     def inner1(*args,**kwargs):
         print("7")
         func(*args,**kwargs)
     return inner1
    def wrapper2(func):
     def inner2(*args,**kwargs):
         func(*args,**kwargs)
         print("15")
     return inner2
    @wrapper2
    @wrapper1
    @wrapper       # foo = wrapper(foo)
    def foo():    # 先执行里被装饰函数最近的那个装饰器
     print("is  foo")
    foo()
    

53. 求结果

    lst = [1,2,[]] * 3
    lst[-1].append(10)
    print(lst)
    

第二部分 可选题

1. 如何获取列表中第二大的值？
2. 简述Python内存管理机制。
3. 简述Python的垃圾回收机制。
4. 请用两个队列来实现一个栈。
5. 请用Python实现一个链表。
6. 请用Python实现链表的逆转。