美文网首页
重点汇总-python常见问题1

重点汇总-python常见问题1

作者: 时间之友 | 来源:发表于2017-12-17 17:29 被阅读37次

    1. 简述函数式编程

    解释一: 在函数式编程中,函数是基本单位,变量只是一个名称,而不是一个存储单元。除了匿名函数外,Python还使fliter(),map(),reduce(),apply()函数来支持函数式编程。

    解释二: 廖---函数是Python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单的任务,这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。
    而函数式编程(请注意多了一个“式”字)——Functional Programming,虽然也可以归结到面向过程的程序设计,但其思想更接近数学计算。

    函数式编程就是一种抽象程度很高的编程范式,纯粹的函数式编程语言编写的函数没有变量,因此,任意一个函数,只要输入是确定的,输出就是确定的,这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言,由于函数内部的变量状态不确定,同样的输入,可能得到不同的输出,因此,这种函数是有副作用的。

    函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数!

    解释三: 维基百科---函数式编程是一种编程模型,他将计算机运算看做是数学中函数的计算,并且避免了状态以及变量的概念。


    2. 什么是匿名函数,匿名函数有什么局限性

    解释一:匿名函数,也就是lambda函数,通常用在函数体比较简单的函数上。匿名函数顾名思义就是函数没有名字,因此不用担心函数名冲突。不过Python对匿名函数的支持有限,只有一些简单的情况下可以使用匿名函数。

    解释二: fluent-python---Python 简单的句法限制了 lambda 函数的定义体只能使用纯表达式。 换句话说, lambda 函数的定义体中不能赋值, 也不能使用 while和 try 等 Python 语句,在参数列表中最适合使用匿名函数。除了作为参数传给高阶函数之外, Python 很少使用匿名函数。


    3. 如何捕获异常,常用的异常机制有哪些?

    如果我们没有对异常进行任何预防,那么在程序执行的过程中发生异常,就会中断程序,调用python默认的异常处理器,并在终端输出异常信息。

    try...except...finally语句:当try语句执行时发生异常,回到try语句层,寻找后面是否有except语句。找到except语句后,会调用这个自定义的异常处理器。except将异常处理完毕后,程序继续往下执行。finally语句表示,无论异常发生与否,finally中的语句都要执行。

    assert语句:判断assert后面紧跟的语句是True还是False,如果是True则继续执行print,如果是False则中断程序,调用默认的异常处理器,同时输出assert语句逗号后面的提示信息。

    with语句:如果with语句或语句块中发生异常,会调用默认的异常处理器处理,但文件还是会正常关闭

    补充:记录异常 logging 模块,抛出错误 raise语句


    4. copy()deepcopy()的区别

    copy是浅拷贝,只拷贝可变对象的父级元素。 deepcopy是深拷贝,递归拷贝可变对象的所有元素。
    参考文章


    5. 函数装饰器有什么作用(常考)

    装饰器本质上是一个Python函数,它可以让其他函数在不需要做任何代码变动的前提下增加额外功能,装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景,比如:插入日志、性能测试、事务处理、缓存、权限校验等场景。有了装饰器,就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

    6. 简述Python的作用域以及Python搜索变量的顺序

    Python作用域简单说就是一个变量的命名空间。代码中变量被赋值的位置,就决定了哪些范围的对象可以访问这个变量,这个范围就是变量的作用域。在Python中,只有模块(module),类(class)以及函数(def、lambda)才会引入新的作用域。Python的变量名解析机制也称为 LEGB 法则:本地作用域(Local)→当前作用域被嵌入的本地作用域(Enclosing locals)→全局/模块作用域(Global)→内置作用域(Built-in)


    7. 新式类和旧式类的区别,如何确保使用的类是新式类

    为了统一类(class)和类型(type),python在2.2版本引进来新式类。在2.1版本中,类和类型是不同的。

    为了确保使用的是新式类,有以下方法:

    放在类模块代码的最前面 __metaclass__ = type
    从内建类object直接或者间接地继承
    在python3版本中,默认所有的类都是新式类。


    8. 简述__new____init__的区别

    创建一个新实例时调用__new__,初始化一个实例时用__init__,这是它们最本质的区别。

    new方法会返回所构造的对象,init则不会.

    new函数必须以cls作为第一个参数,而init则以self作为其第一个参数.


    9. Python垃圾回收机制(常考)

    Python GC主要使用引用计数(reference counting)来跟踪和回收垃圾。在引用计数的基础上,通过“标记-清除”(mark and sweep)解决容器对象可能产生的循环引用问题,通过“分代回收”(generation collection)以空间换时间的方法提高垃圾回收效率。

      1. 引用计数

    PyObject是每个对象必有的内容,其中ob_refcnt就是做为引用计数。当一个对象有新的引用时,它的ob_refcnt就会增加,当引用它的对象被删除,它的ob_refcnt就会减少.引用计数为0时,该对象生命就结束了。

    优点:
    简单 实时性
    缺点:
    维护引用计数消耗资源 循环引用

      1. 标记-清除机制

    基本思路是先按需分配,等到没有空闲内存的时候从寄存器和程序栈上的引用出发,遍历以对象为节点、以引用为边构成的图,把所有可以访问到的对象打上标记,然后清扫一遍内存空间,把所有没标记的对象释放。

      1. 分代技术

    分代回收的整体思想是:将系统中的所有内存块根据其存活时间划分为不同的集合,每个集合就成为一个“代”,垃圾收集频率随着“代”的存活时间的增大而减小,存活时间通常利用经过几次垃圾回收来度量。

    Python默认定义了三代对象集合,索引数越大,对象存活时间越长。


    10. Python中的 @property 有什么作用?如何实现成员变量的只读属性?

    @property装饰器就是负责把一个方法变成属性调用,通常用在属性的get方法和set方法,通过设置@property可以实现实例成员变量的直接访问, 又保留了参数的检查。另外通过设置get方法而不定义set方法可以实现成员变量的只读属性。


    11. *args and **kwargs

    *args代表位置参数,它会接收任意多个参数并把这些参数作为元组传递给函数。**kwargs代表的关键字参数,允许你使用没有事先定义的参数名,另外,位置参数一定要放在关键字参数的前面。


    12. 有用过with statement吗?它的好处是什么?具体如何实现?

    with语句适用于对资源进行访问的场合,确保不管使用过程中是否发生异常都会执行必要的“清理”操作,释放资源,比如文件使用后自动关闭、线程中锁的自动获取和释放等。

    13. what will be the output of the code below? explain your answer?

    def extend_list(val, list=[]):     # 考察默认参数的坑
        list.append(val)
        return list
    
    list1 = extend_list(10)
    list2 = extend_list(123, [])     # 不使用默认参数的 [ ]
    list3 = extend_list('a')
    print(list1)
    print(list2)
    print(list3)
    
    In [158]: list1
    Out[158]: [10, 'a']   # 记住,当函数的参数是可变参数时要极其小心,list即为可变,但
    
    In [159]: list2      #  定义了list,重新生成
    Out[159]: [123]
    
    In [160]: list3    
    Out[160]: [10, 'a']
    

    上述可参考廖的教程:
    默认参数很有用,但使用不当,也会掉坑里。默认参数有个最大的坑,演示如下:

    def add_end(L=[]):
        L.append('END')
        return L
    
    >>> add_end([1, 2, 3])    #   正常调用似乎没问题
    [1, 2, 3, 'END']
    
    >>> add_end()    # 第一次使用默认参数调用
    ['END']
    
    >>> add_end()    # 开始异常了
    ['END', 'END']
    
    #  很多初学者很疑惑,默认参数是[],但是函数似乎每次都“记住了”上次添加了'END'后的list。
    #  Python函数在定义的时候,默认参数L的值就被计算出来了,即[],因为默认参数L也是一个变量,它指向对象[],
    每次调用该函数,如果改变了L的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时的[]了。
    
    #  要修改上面的例子,我们可以用None这个不变对象来实现:
    def add_end(L=None):
        if L is None:
            L = []
        L.append('END')
        return L
    

    定义默认参数要牢记一点:默认参数必须指向不变对象!

    class Parent(object):      #  考察继承 
        x = 1
    
    class Child1(Parent):
        pass
    
    class Child2(Parent):
        pass
    
    print(Parent.x, Child1.x, Child2.x)     # [1,1,1]
    Child1.x = 2
    print(Parent.x, Child1.x, Child2.x)     # [1,2,1]
    Partent.x = 3
    print(Parent.x, Child1.x, Child2.x)     # [3,2,3]
    

    14. 在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序。请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数。

    arr = [[1,4,7,10,15], [2,5,8,12,19], [3,6,9,16,22], [10,13,14,17,24], [18,21,23,26,30]] # 竖着排列更形象

    def getNum(num, data=None):     # 他人做法
        while data:
            if num > data[0][-1]:
                del data[0]
                print(data)
                getNum(num, data=None)
            elif num < data[0][-1]:
                data = list(zip(*data))
                del data[-1]
                data = list(zip(*data))
                print(data)
                getNum(num, data=None)
            else:
                return True
                data.clear()
        return False
    
    
    if __name__ == '__main__':
        print(getNum(18, arr))
      # ------------------------
    
    In [237]: def find_num(arr, x):   #  我的做法
         ...:     L = []
         ...:     for i in arr:
         ...:         for k in i:
         ...:             L.append(k)
         ...:     M = set(L) - set([x])
         ...:     if M == set(L):
         ...:         print('false')
         ...:     else:
         ...:         print('true')     #   find_num(arr, 10)  测试结果: True
    

    15. 获取最大公约数、最小公倍数

    最大公约数

    def gcd(a, b):    # 这个就是大名鼎鼎的 欧几里德 算法,又称辗转相除法 
        while a != 0:
            a, b = b % a, a
     
        return b
    
    def maxCommon(a, b):     # 这么写也可以
        while b: 
            a, b = b, a%b   
        return a      #  这个return注意要和while并列,否则会出现问题!
    

    最小公倍数

    def minCommon(a, b):
        c = a*b
        while b: 
            a, b = b,  a%b
        return c//a    # c 除以最大公约数,即得最小公倍数
    

    16. 获取中位数

    def median(data):
        data.sort()
        half = len(data) // 2
        return (data[half] + data[~half])/2   # ~ 是按位反转,二进制数0 1对换
    

    按位翻转
    计算机中的符号数有三种表示方法,即原码反码补码


    17. 输入一个整数,输出该数二进制表示中1的个数。其中负数用补码表示

    def getOneCount(num):
        if num > 0:
            count = b_num.count('1')
            print(b_num)
            return count
        elif num < 0:
            b_num = bin(~num)
            count = 8 - b_num.count('1')
            return count
        else:
            return 8
    
    if __name__ == '__main__':
        print(getOneCount(5))
        print(getOneCount(-5))
        print(getOneCount(0))
    

    18. B+树的结构 ----待解决

    19. Redis 并发

    https://www.cnblogs.com/wang-yc/p/5693288.html
    https://www.zhihu.com/question/22334971

    相关文章

      网友评论

          本文标题:重点汇总-python常见问题1

          本文链接:https://www.haomeiwen.com/subject/sudywxtx.html