Interview

1. Python和Java、PHP、C、C#、C++等其他语言的对比？

   # C语言：通过指针可直接靠近硬件的操作，但指针操作不做保护，带来很多不安全的因素。
   # C++：C语言的继承，编译型语言。
   # C#：微软发布的，和Java比较相似，如单一继承、接口等
   # Java：简单、面向对象、分布式、解释型、健壮、安全与系统无关、可移植、高性能、多线程和动态语言。
   # PHP语言：用于web开发领域
   # Python：胶水语言、面向对象、简洁而优雅
   

2. 简述解释型和编译型语言？

   # 编译型：要编译器，相当于谷歌翻译，执行快，跨平台差，开发效率慢，调试麻烦
   # 解释型：要解释器，相当于同生传译，跨平台好，执行慢，开发效率快，方便调试
   

3. Python解释器种类及特点？

   # CPython:C语言开发，官方版本
   # IPython：基于CPython之上，跟国产浏览器差不多，虽外观不同，但内核都是调用IE
   # PyPy：目标是执行速度，采用JIT（just in time）技术，对代码进行动态编译。
   # Jython：运行在Java平台的Python解释器，将代码编译成Java字节码执行
   

4. 位bit、字节B、KB、MB、GB的关系？

   8bit=1B;1024B=1KB;1024KB=1MB;1024MB=1GB
   

5. 请至少列举5个PEP8规范

   1.使用空格（space）表示缩进而不是用tab（制表符）
   2.每行的字符数不应超过79
   3.函数与类之间应该用两个空行隔开
   4.在同一个类中，各方法之间应该用一个空行隔开
   5.函数、变量及属性应该用小写字母拼写，各单词之间以下划线相连
   

6. 求以下结果

   print(1 or 3)  # 1
   print(1 and 3)  # 3
   print(0 and 1)  # 0
   print(0 and 2 and 1)  # 0
   print(0 and 2 or 1)  # 1
   print(0 and 2 or 1 or 4)  # 1
   print(0 or False and 1)  # False，先计算and
   # 逻辑操作符and，如果两者为真，则返回第二个值，反之，返回第一个值
   # 逻辑操作符or，如果两者为真，则返回第一个值，反之，返回第二个值
   # False:0、None、False、空数据类型，其余全为True
   # and的优先级大于or
   

7. ASCII、Unicode、utf-8、gbk的区别？

   # ASCII：英文字符与二进制进行联系，规定了128个字符，如大写字母（65-90），小写字母（97-122）.
   # Unicode：一种所有符号的编码，规定每个符号用2个字节表示
   # utf-8:可変长编码，1-4字节表示一个符号。
   # gbk：对GB2312的扩展并兼容，大部分汉字占两个字节
   

8. 字节码和机器码的区别？

   字节码是一种中间状态（中间码）的二进制代码，需要直译器转义后才能成为机器码
   

9. 三元运算、交叉赋值、解压取值编写格式

   条件成立 if 条件 else 条件不成立
   a,b=b,a
   a,b,c=[1,2,3]
   a,_,c=[1,2,3]
   

10. Python2和Python的区别？

    # 打印方式
    py2：print "hello"
    py3：print("hello")
    # 用户输入方式
    py2：input_raw()
    py3：input()
    # 默认编码方式
    py2：ASCII
    py3：utf-8
    # 字符串
    py2：Unicode表示字符串，str表示字节
    py3：str表示字符串，byte表示字节
    # int和long
    py2:int整型，long长整型
    py3：只有int类型，无long类型
    # xrange和range
    py2：xrange生成器，range列表对象
    py3：range生成器，无xrange
    

11. 如何实现字符串的反转？

    s = "hello world"
    print(s[::-1])
    

12. 文件操作时，xrealines和readlines的区别？

    # readlines():把文件的全部内容读到内存，并返回一个列表，每一行为一个元素，当文件过大，占用过多内存。
    # readline():读取文件中的第一行到内存中，并以字符串形式返回
    # read():读取文件中的全部内容到内存，并以字符串形式返回每一行数据
    # xreadlines():直接返回一个iter()迭代器，已弃用，直接for循环迭代文件对象即可。
    f = open("test.txt", 'r', encoding='utf-8')
    data = f.readlines()
    print(data)  # ['hello
    ', 'world']
    

13. is和==的区别？

    is比较的是内存地址，而==比较的是值
    

14. 哪些情况下，y!=x-(x-y)会成立？

    # x,y是两个不相等的非空集合
    # 集合符号：&交集、|并集、-差集、^对称差集、>父集、<子集
    y = {1, 2, 3}
    x = {4, 5, 6}
    print(x - y)  # {4, 5, 6}
    print(y != x - (x - y))  # True
    

15. 现有字典dic={"a":23,"b":51,"c":11,"d":34}，请按字典中的value值进行降序排序？

    dic = {"a": 23, "b": 51, "c": 11, "d": 34}
    print(sorted(dic, key=lambda i: dic[i], reverse=True))
    # ['b', 'd', 'a', 'c']
    print(dic.items())
    # dict_items([('a', 23), ('b', 51), ('c', 11), ('d', 34)])
    print(sorted(dic.items(), key=lambda i: i[1], reverse=True))
    # [('b', 51), ('d', 34), ('a', 23), ('c', 11)]
    

16. 简要说明字典和json的区别？

    字典是一种数据结构，key值必须能hash即唯一，而json是一种数据的表现形式，必须是字符串
    

17. 什么是可变类型、不可变类型？

    可变类型：值变id不变，如列表、字典、集合
    不可变类型：值变id变，如数值、字符串、元组
    

18. 字典推导式、列表推导式和生成器推导式？

    lis = [1, 2, 3]
    # 字典推导式
    print({k: v for (k, v) in enumerate(lis)})  # {0: 1, 1: 2, 2: 3}
    # 列表推导式
    print([i for i in range(3)])  # [0, 1, 2]
    # 生成器推导式
    print((i for i in range(3)))  # <generator object <genexpr> at 0x0000000002171E60>
    for j in (i for i in range(3)):
        print(j)
    #需求：产生一个公差为11的等差数列
    print([i * 11 for i in range(10)])
    

19. 描述字典中的item()方法与iteritems()的不同

    item():将字典中的所有项以列表无序的形式返回。
    iteritem():py2中使用，返回一个迭代器，已弃用。
    

20. 将字符串"k:1|k1:2|k2:3|k3:4"处理成字典{k:1,k1:2,k2:3,k3:4}

    s = "k:1|k1:2|k2:3|k3:4"
    dic = {}
    for i in s.split('|'):
        k, v = i.split(':')
        dic[k] = v
    print(dic)
    

21. 常见的字符串格式化有哪几种？

    name = "allen"
    # 占位符
    print("hello,%s" % name)
    # format
    print("hello,{}".format(name))
    # f-string
    print(f"hello,{name}")
    

22. 简述字符串驻留机制？

    对于短字符串，将其赋值给多个不同的对象时，内存中只有一个副本，多个对象共享该副本，长字符串不遵守驻留机制。
    驻留适用范围：由数字、字符和下划线组成的python标识符以及小整数池[-5,256]。
    

23. 下面代码的输出结果是什么？

    lis = ['a', 'b', 'c', 'd', 'e']
    print(lis[10])  # IndexError
    print(lis[10:])  # []
    

24. 实现删除一个list里面的重复元素？

    # 方式一
    lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
    lis1 = list(set(lis))
    print(lis1)
    # 方式二：保持原来的顺序
    lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
    lis1 = list(set(lis))
    lis2 = lis1.sort(key=lis.index)
    print(lis1) #['b', 'c', 'd', 'a']
    # 方式三：保持原来的顺序
    lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
    lis1 = sorted(set(lis), key=lis.index)
    print(lis1)
    # 方式四：保持原来的顺序-遍历
    lis = ['b', 'c', 'd', 'b', 'c', 'a', 'a']
    new_lis = []
    for i in lis:
        if i not in new_lis:
            new_lis.append(i)
    print(new_lis)
    

25. 下面这段代码的输出结果是什么？并解释。

    def extendlist(val, lis=[]):
        lis.append(val)
        return lis
    lis1 = extendlist(10)
    lis2 = extendlist(123, [])
    lis3 = extendlist('a')
    print(f'lis1={lis1}')  # lis1=[10, 'a']
    print(f'lis2={lis2}')  # lis2=[123]
    print(f'lis3={lis3}')  # lis3=[10, 'a']
    
    def extend_dic(key, dic={}):
        dic[key] = 1
        return dic
    dic1 = extend_dic('a')
    dic2 = extend_dic('b', {})
    dic3 = extend_dic('c')
    print(f'dic1={dic1}')  # dic1={'a': 1, 'c': 1}
    print(f'dic2={dic2}')  # dic2={'b': 1}
    print(f'dic3={dic3}')  # dic3={'a': 1, 'c': 1}
    # 新的默认列表只在函数被定义那一刻创建一次，当extendlist被没有指定特定参数lis调用时，这组lis的值随后将被使用，因为带有默认参数的表达式在函数定义阶段时被计算，不是在调用时被计算。
    

26. 将以下3个函数按照执行效率高低排序？

    import random
    import cProfile
    def f1(x):
        l1 = sorted(x)
        l2 = [i for i in l1 if i < 0.5]
        return [i * i for i in l2]
    def f2(x):
        l1 = [i for i in x if i < 0.5]
        l2 = sorted(l1)
        return [i * i for i in l2]
    def f3(x):
        l1 = [i * i for i in x]
        l2 = sorted(l1)
        return [i for i in l2 if i < (0.5 * 0.5)]
    x = [random.random() for i in range(100000)]
    cProfile.run('f1(x)')
    cProfile.run('f2(x)')
    cProfile.run('f3(x)')
    # 执行效率：f2、f1、f3
    # 利用cProfile模块分析代码的性能
    

27. 列举字符串、列表、元组、字典常用方法

    字符串：replace、strip、split、reverse、upper、join、lower
    列表：append、pop、insert、remove、sort、count、index
    元组：index、count、len、dir
    字典：get、keys、values、pop、clear、update、items
    

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

    在绝大多数语言当中都有反射机制，是很多框架的基石，用字符串形式访问对象的属性，调用对象的方法，但不能去访问方法，python一切皆对象，都可以使用反射。
    

29. 简述Python的深浅拷贝？

    在python中，对象赋值实际上是对象的引用。当创建一个对象，然后把它赋给另一个变量时，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。注意：拷贝、浅拷贝、深拷贝都是针对可变类型数据而言的。

    # 拷贝：如果l2是l1的拷贝对象，l1内部的任何数据类型的元素变化，那么l2内部的元素也会跟着改变，因为可变类型值变id不变。
    l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
    l2 = l1
    l1.append('g')
    print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
    print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
    # 浅拷贝：如果l2是l1的浅拷贝对象，l1内的不可变元素发生了改变，l2不变；但是l1内的可变元素发生了改变，l2也会跟着改变。
    import copy
    l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
    l2 = copy.copy(l1)
    l1.append('g')
    print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
    print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f']]
    l1[3].append('h')
    print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f', 'h'], 'g']
    print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f', 'h']]
    # 深拷贝：如果l2是l1的深拷贝对象，那么l1内的不可变元素发生了改变，l2不变；如果l1内的可变元素发生了改变，l2也不会变，即l2永远不会因为l1变化而变化。
    import copy
    l1 = ['a', 'b', 'c', ['d', 'e', 'f']]
    l2 = copy.deepcopy(l1)
    l1.append('g')
    print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f'], 'g']
    print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f']]
    l1[3].append('h')
    print(l1)  # ['a', 'b', 'c', ['d', 'e', 'f', 'h'], 'g']
    print(l2)  # ['a', 'b', 'c', ['d', 'e', 'f']]