基础篇2--【python】面试题汇总

1.python常用模块都有那些

OS模块
    os.remove('path/filename')  删除文件
    os.rename(oldname, newname) 重命名文件
    os.walk()  生成目录树下的所有文件名
    os.chdir('dirname')  改变目录
    os.mkdir/makedirs('dirname') 创建目录/多层目录
    os.rmdir/removedirs('dirname')  删除目录/多层目录
    os.listdir('dirname') 列出指定目录的文件
    os.getcwd() 获取当前工作目录
    os.chmod()  改变目录权限
    os.path.basename('path/filename') 去掉目录路径，返回文件名
    os.path.dirname('path/filename') 去掉文件名，返回目录路径
    os.path.join(path1[,path2[,...]])  将分离的各部分组合成一个路径名
    os.path.split('path') 返回(dirname(),basename())元组
    os.path.splitext() 返回(filename,extension)元组
    os.path.getatime\ctime\mtime 分别返回最近访问，创建，修改时间
    os.path.getsize() 返回文件大小
    os.path.exists()  判断是否存在
    os.path.isabs() 判断是否为绝对路径
    os.path.isdir() 判断是否为目录
    os.path.isfile() 判断是否为文件
sys模块
    sys.argv 命令行参数List,第一个元素是程序本身路径
    sys.modules.keys() 返回所有已经导入的模块列表
    sys.exc_info() 获取当前正在处理的异常类，exc_type,exc_value,exc_traceback当前处理的一场详细信息
    sys.exit(n) 退出程序，正常退出时exit(0)
    sys.hexversion 获取python解释器程序的版本值，16进制格式：0x020403F0
    sys.version 获取python解释器程序的版本信息
    sys.maxint 最大的Int值
    sys.maxunicode 最大的Unicode值
    sys.modules 返回系统导入的模块，key是模块名，value是模块
    sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
    sys.platform 返回操作系统平台名称
    sys.stdout 标准输出
    sys.stdin 标准输入
    sys.stderr 错误输出
    sys.exc_clear() 用来清除当前线程所出现的最近的错误信息
    sys.exec_prefix 返回平台独立的python文件安装的位置
    sys.byteorder 本地字节规则的指示器，big-endian平台的值是'big',little-endian平台的值是'little'
    sys.copyright 记录python版权相关的东西
    sys.api_version 解释器的C的API版本

time模块
    time.time()  生成timestamp 时间戳 #1571576335.8366842
    time.localtime() 生成struct_time 本地时间 #time.struct_time(tm_year=2019, tm_mon=10, tm_mday=20, tm_hour=20, tm_min=59, tm_sec=40, tm_wday=6, tm_yday=293, tm_isdst=0)

        >>> time.localtime(1571576335.8366842)
            time.struct_time(tm_year=2019, tm_mon=10, tm_mday=20, tm_hour=20, tm_min=58, tm_sec=55, tm_wday=6, tm_yday=293, tm_isdst=0)


        >>> time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')
            time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, tm_wday=3, tm_yday=125, tm_isdst=-1)

        >>> time.strftime("%Y-%m-%d %X",time.localtime())
            '2019-10-20 21:04:15'

        >>> time.asctime(time.localtime())
            'Sun Oct 20 21:04:41 2019'
        >>> time.ctime(time.time())
            'Sun Oct 20 21:04:47 2019'

        >>> t1 = time.time()   #时间的加减
        >>> t2 = t1 + 10
        >>> print(t2)
            1571576798.2929437
        >>> print(time.ctime(t2))
            Sun Oct 20 21:06:38 2019
        >>> print(time.ctime(t1))
            Sun Oct 20 21:06:28 2019


datetime模块
    datatime模块重新封装了time模块，提供更多接口，提供的类有：date,time,datetime,timedelta,tzinfo。

        >>> datetime.date.fromtimestamp(1571576335.8366842)
            datetime.date(2019, 10, 20)
        >>> datetime.datetime.now()
            datetime.datetime(2019, 10, 20, 21, 22, 40, 422035)
        >>> datetime.date.weekday(obj) #返回一个日期对象的星期数,周一是0
            6
        >>> datetime.date.isoweekday(obj) #返回一个日期对象的星期数,周一是1
            7
        >>> datetime.date.isocalendar(obj) #把日期对象返回一个带有年月日的元组
            (2019, 42, 7)
        >>> datetime.datetime.strptime('2014-03-16 12:21:21',"%Y-%m-%d %H:%M:%S") #将字符串转为datetime对象
            datetime.datetime(2014, 3, 16, 12, 21, 21)
        >>> datetime.datetime.strftime(datetime.datetime.now(), '%Y%m%d %H%M%S')  #将datetime对象转换为str表示形式
            '20191020 213253'

        >>> datetime.date.today().timetuple()  #转换为时间戳datetime元组对象，可用于转换时间戳
            time.struct_time(tm_year=2019, tm_mon=10, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=293, tm_isdst=-1)

        >>> obj2 = datetime.datetime.now().timetuple()
        >>> time.mktime(obj2)   #将datetime元组对象转为时间戳
            1571578818.0

hashlib,md5模块
    md5 加密
        >>> string = 'xueximd5'
        >>> md5 = hashlib.md5()
        >>> md5.update(string.encode('utf-8'))
        >>> res = md5.hexdigest()
        >>> print(res)
            e2d1f3e0e8fd3b83a7b3f519f3b89943

    sha1 加密

        >>> obj = '123'
        >>> sha1 = hashlib.sha1()
        >>> sha1.update(obj.encode('utf-8'))
        >>> res = sha1.hexdigest()
        >>> print(res)
            40bd001563085fc35165329ea1ff5c5ecbdbbeef

    sha256 加密
        >>> obj = '123'
        >>> sha256 = hashlib.sha256()
        >>> sha256.update(obj.encode('utf-8'))
        >>> res = sha256.hexdigest()
        >>> print(res)
            a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3

    sha384 加密
        >>> obj = "123"
        >>> sha384 = hashlib.sha384()
        >>> sha384.update(obj.encode('utf-8'))
        >>> res = sha384.hexdigest()
        >>> print(res)
            9a0a82f0c0cf31470d7affede3406cc9aa8410671520b727044eda15b4c25532a9b5cd8aaf9cec4919d76255b6bfb00f

    sha512 加密
        >>> obj = "123"
        >>> sha512.update(obj.encode('utf-8'))
        >>> res = sha512.hexdigest()
        >>> print(res)
            3c9909afec25354d551dae21590bb26e38d53f2173b8d3dc3eee4c047e7ab1c1eb8b85103e3be7ba613b31bb5c9c36214dc9f14a42fd7a2fdb84856bca5c44c2

random模块
    random.random() 产生0-1的随机浮点数
    random.uniform(a, b) 产生指定范围内的随机浮点数
    random.randint(a, b) 产生指定范围内的随机整数
    random.randrange([start], stop[, step]) 从一个指定步长的集合中产生随机数
    random.choice(sequence) 从序列中产生一个随机数
    random.shuffle(x[, random]) 将一个列表中的元素打乱
    random.sample(sequence, k) 从序列中随机获取指定长度的片断

types模块
    types模块中定义了Python中所有的类型，包括NoneType,  TypeType,  IntType,  FloatType,  BooleanType,  BufferType,  BuiltinFunctionType,  BuiltinMethodType,   ClassType,  CodeType,  ComplexType,  DictProxyType,  DictType,  DictionaryType等。
        >>> import types
        >>> type(1)
            <class 'int'>
        >>> type('1')
            <class 'str'>
        >>> type(True)
            <class 'bool'>
        >>> type(2.3)
            <class 'float'>

string模块
    str.capitalize() 把字符串的第一个字符大写
    str.center(width) 返回一个原字符串居中，并使用空格填充到width长度的新字符串
    str.ljust(width) 返回一个原字符串左对齐，用空格填充到指定长度的新字符串
    str.rjust(width) 返回一个原字符串右对齐，用空格填充到指定长度的新字符串
    str.zfill(width) 返回字符串右对齐，前面用0填充到指定长度的新字符串
    str.count(str,[beg,len]) 返回子字符串在原字符串出现次数，beg,len是范围
    str.decode(encodeing[,replace]) 解码string,出错引发ValueError异常
    str.encode(encodeing[,replace]) 解码string
    str.endswith(substr[,beg,end]) 字符串是否以substr结束，beg,end是范围
    str.startswith(substr[,beg,end]) 字符串是否以substr开头，beg,end是范围
    str.expandtabs(tabsize = 8) 把字符串的tab转为空格，默认为8个
    str.find(str,[stat,end]) 查找子字符串在字符串第一次出现的位置，否则返回-1
    str.index(str,[beg,end]) 查找子字符串在指定字符中的位置，不存在报异常
    str.isalnum() 检查字符串是否以字母和数字组成，是返回true否则False
    str.isalpha() 检查字符串是否以纯字母组成，是返回true,否则false
    str.isdecimal() 检查字符串是否以纯十进制数字组成，返回布尔值
    str.isdigit() 检查字符串是否以纯数字组成，返回布尔值
    str.islower() 检查字符串是否全是小写，返回布尔值
    str.isupper() 检查字符串是否全是大写，返回布尔值
    str.isnumeric() 检查字符串是否只包含数字字符，返回布尔值
    str.isspace() 如果str中只包含空格，则返回true,否则FALSE
    str.title() 返回标题化的字符串（所有单词首字母大写，其余小写）
    str.istitle() 如果字符串是标题化的(参见title())则返回true,否则false
    str.join(seq) 以str作为连接符，将一个序列中的元素连接成字符串
    str.split(str=‘‘,num) 以str作为分隔符，将一个字符串分隔成一个序列，num是被分隔的字符串
    str.splitlines(num) 以行分隔，返回各行内容作为元素的列表
    str.lower() 将大写转为小写
    str.upper() 转换字符串的小写为大写
    str.swapcase() 翻换字符串的大小写
    str.lstrip() 去掉字符左边的空格和回车换行符
    str.rstrip() 去掉字符右边的空格和回车换行符
    str.strip() 去掉字符两边的空格和回车换行符
    str.partition(substr) 从substr出现的第一个位置起，将str分割成一个3元组。
    str.replace(str1,str2,num) 查找str1替换成str2，num是替换次数
    str.rfind(str[,beg,end]) 从右边开始查询子字符串
    str.rindex(str,[beg,end]) 从右边开始查找子字符串位置 
    str.rpartition(str) 类似partition函数，不过从右边开始查找
    str.translate(str,del=‘‘) 按str给出的表转换string的字符，del是要过虑的字符

urllib模块
    urllib.quote(string[,safe]) 对字符串进行编码。参数safe指定了不需要编码的字符
    urllib.unquote(string) 对字符串进行解码
    urllib.quote_plus(string[,safe]) 与urllib.quote类似，但这个方法用‘+‘来替换‘ ‘，而quote用‘%20‘来代替‘ ‘
    urllib.unquote_plus(string ) 对字符串进行解码
    urllib.urlencode(query[,doseq]) 将dict或者包含两个元素的元组列表转换成url参数。
    例如 字典{‘name‘:‘wklken‘,‘pwd‘:‘123‘}将被转换为”name=wklken&pwd=123″
    urllib.pathname2url(path) 将本地路径转换成url路径
    urllib.url2pathname(path) 将url路径转换成本地路径
    urllib.urlretrieve(url[,filename[,reporthook[,data]]]) 下载远程数据到本地
    filename：指定保存到本地的路径（若未指定该，urllib生成一个临时文件保存数据）
    reporthook：回调函数，当连接上服务器、以及相应的数据块传输完毕的时候会触发该回调
    data：指post到服务器的数据
    rulrs = urllib.urlopen(url[,data[,proxies]]) 抓取网页信息，[data]post数据到Url,proxies设置的代理
    urlrs.readline() 跟文件对象使用一样
    urlrs.readlines() 跟文件对象使用一样
    urlrs.fileno() 跟文件对象使用一样
    urlrs.close() 跟文件对象使用一样
    urlrs.info() 返回一个httplib.HTTPMessage对象，表示远程服务器返回的头信息
    urlrs.getcode() 获取请求返回状态HTTP状态码
    urlrs.geturl() 返回请求的URL

re模块
    一.常用正则表达式符号和语法：
        '.' 匹配所有字符串，除\n以外
        ‘-’ 表示范围[0-9]
        '*' 匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
        '+' 匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+
        '^' 匹配字符串开头
        ‘$’ 匹配字符串结尾 re
        '\' 转义字符， 使后一个字符改变原来的意思，如果字符串中有字符*需要匹配，可以\*或者字符集[*] re.findall(r'3\*','3*ds')结['3*']
        '*' 匹配前面的字符0次或多次 re.findall("ab*","cabc3abcbbac")结果：['ab', 'ab', 'a']
        ‘?’ 匹配前一个字符串0次或1次 re.findall('ab?','abcabcabcadf')结果['ab', 'ab', 'ab', 'a']
        '{m}' 匹配前一个字符m次 re.findall('cb{1}','bchbchcbfbcbb')结果['cb', 'cb']
        '{n,m}' 匹配前一个字符n到m次 re.findall('cb{2,3}','bchbchcbfbcbb')结果['cbb']
        '\d' 匹配数字，等于[0-9] re.findall('\d','电话:10086')结果['1', '0', '0', '8', '6']
        '\D' 匹配非数字，等于[^0-9] re.findall('\D','电话:10086')结果['电', '话', ':']
        '\w' 匹配字母和数字，等于[A-Za-z0-9] re.findall('\w','alex123,./;;;')结果['a', 'l', 'e', 'x', '1', '2', '3']
        '\W' 匹配非英文字母和数字,等于[^A-Za-z0-9] re.findall('\W','alex123,./;;;')结果[',', '.', '/', ';', ';', ';']
        '\s' 匹配空白字符 re.findall('\s','3*ds \t\n')结果[' ', '\t', '\n']
        '\S' 匹配非空白字符 re.findall('\s','3*ds \t\n')结果['3', '*', 'd', 's']
        '\A' 匹配字符串开头
        '\Z' 匹配字符串结尾
        '\b' 匹配单词的词首和词尾，单词被定义为一个字母数字序列，因此词尾是用空白符或非字母数字符来表示的
        '\B' 与\b相反，只在当前位置不在单词边界时匹配
        '(?P<name>...)' 分组，除了原有编号外在指定一个额外的别名 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{8})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '19930614'}
        [] 是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。[\s*]表示空格或者*号。
    二.常用的re函数：
        方法/属性 作用
        re.match(pattern, string, flags=0) 从字符串的起始位置匹配，如果起始位置匹配不成功的话，match()就返回none
        re.search(pattern, string, flags=0) 扫描整个字符串并返回第一个成功的匹配
        re.findall(pattern, string, flags=0) 找到RE匹配的所有字符串，并把他们作为一个列表返回
        re.finditer(pattern, string, flags=0) 找到RE匹配的所有字符串，并把他们作为一个迭代器返回
        re.sub(pattern, repl, string, count=0, flags=0) 替换匹配到的字符串

math模块
    ceil:取大于等于x的最小的整数值，如果x是一个整数，则返回x
    copysign:把y的正负号加到x前面，可以使用0
    cos:求x的余弦，x必须是弧度
    degrees:把x从弧度转换成角度
    e:表示一个常量
    exp:返回math.e,也就是2.71828的x次方
    expm1:返回math.e的x(其值为2.71828)次方的值减１
    fabs:返回x的绝对值
    factorial:取x的阶乘的值
    floor:取小于等于x的最大的整数值，如果x是一个整数，则返回自身
    fmod:得到x/y的余数，其值是一个浮点数
    frexp:返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围
    fsum:对迭代器里的每个元素进行求和操作
    gcd:返回x和y的最大公约数
    hypot:如果x是不是无穷大的数字,则返回True,否则返回False
    isfinite:如果x是正无穷大或负无穷大，则返回True,否则返回False
    isinf:如果x是正无穷大或负无穷大，则返回True,否则返回False
    isnan:如果x不是数字True,否则返回False
    ldexp:返回x*(2**i)的值
    log:返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)
    log10:返回x的以10为底的对数
    log1p:返回x+1的自然对数(基数为e)的值
    log2:返回x的基2对数
    modf:返回由x的小数部分和整数部分组成的元组
    pi:数字常量，圆周率
    pow:返回x的y次方，即x**y
    radians:把角度x转换成弧度
    sin:求x(x为弧度)的正弦值
    sqrt:求x的平方根
    tan:返回x(x为弧度)的正切值
    trunc:返回x的整数部分

 

2.代码实现分组，将[1,2,3,...100]变成[[1,2,3],[4,5,6],[7,8,9]....]

a = [x for x in range(1, 101)]
b = [a[x:x+3] for x in range(0, 100, 3)]
print(b)

 

3.如何实现[‘1’,’2’,’3’]变成[1,2,3] ?

a = ['1','2',3]
g = [int(x) for x in a]

 

4.如何实现 “1,2,3” 变成 [‘1’,’2’,’3’] ?

a = '1,2,3'
d = list(a.split(','))

 

5.如何用一行代码生成[1,4,9,16,25,36,49,64,81,100]

[i * i for i in range(1,11)]

 

6.一行代码实现删除列表中重复的值

list(set([1, 2, 3, 4, 45, 1, 2, 343, 2, 2]))

 

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

x = 2
def func():
    global x
    x = 1
    return x
func()
    print(x)  # 1

 

8.logging模块的作用？以及应用场景？

　　logging 模块定义的函数和类为应用程序和库的开发实现了一个灵活的事件日志系统
    在程序的出现故障快速定位出错地方及故障分析

9.请用代码简答实现stack

　　

class Stack:
    def __init__(self):
        self.items = []
    def is_empty(self):
    # 判断是否为空
    　　return self.items == []
    def push(self,item):
    # 加入元素
    　　self.items.append(item)
    def pop(self):
    # 弹出元素
    　　return self.items.pop()
    def peek(self):
    # 返回栈顶元素
    　　return self.items[len(self.items)-1]
    def size(self):
    # 返回栈的大小
    　　return len(self.items)
    if __name__ == "__main__":
        stack = Stack()
        stack.push("H")
        stack.push("E")
        stack.push("L")
        print(stack.size())  # 3
        print(stack.peek())  # L 
        print(stack.pop())   # L
        print(stack.pop())   # E
        print(stack.pop())   # H    

 

10.常用字符串格式化有哪几种？

　　1.占位符 %
        >>> print('Hello,%s'%'python')
            Hello,python
    　2.format
        >>> print('{k} is {v}'.format(k='python', v='easy'))
            python is easy
        >>> print('{0} is {1}'.format('python', 'easy'))
            python is easy

11.简述 生成器、迭代器、可迭代对象 以及应用场景？

　　迭代器协议

        　　对象需要提供next方法，它要么返回迭代中的下一项，要么就引起一个Stoplteration异常，终止迭代    

　　可迭代对象      

 　　　　实现了迭代器协议的对象就是可迭代对象（实现方法是实现iter方法）    

　　协议

        　　协议是一种规定，可迭代对象实现迭代器协议，Python的内置工具（如for,sum,min,max,in）就可以使用迭代器协议访问对象。例如文件之所以可以被for循环遍历，就是因为文件对象实现了迭代器协议，也就是说它有next()方法    

　　迭代器

        　　迭代器对象就是实现了iter()和next()方法的对象。其中iter()返回迭代器本身，而next()返回容器的下一个元素，在结尾处引发Stoplnteration异常    　　

　　迭代器有两个方法：

        　　iter() 和 next()
        　　　　list，dict,tuple,string 并不是迭代器，他们只是可迭代对象，但是可以通过iter(list)的方法将他们转换为迭代器

        　　所有的iterable都可以通过内置函数iter()转换为iterator
        　　迭代器的优点：省内存，它是一种通过延时创建的方式生成一个序列，只有在需要的时候才被创建
        　　迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问结束，只能往前不能后退
        　　迭代器有两个基本的方法：iter,next方法
        　　内置函数iter(),next（），本质上都是用的对象的iter()和next()方法

　　生成器

        　　python使用生成器对延迟操作提供支持，所谓延迟操作，是指在需要的时候才产生结果，而不是立即产生结果

　　生成器表达式

             把列表生成式的[]改成(),就创建了一个generatop       

　　生成器函数            

　　　　和常规函数定义一样，但是返回语句returen被yield语句代替，yield语句一次返回一个结果，在每个结果中间，挂起函数的状态，以便下次从它离开的地方继续执行
        　　生成器语法上和普通的函数非常相似，都是用def进行定义。唯一的区别是普通的函数是用return返回，而生成器是通过yield语句返回一个值

       自动实现迭代器协议：

        　　对于生成器，python会自动失效它的可迭代协议，以便用在可以迭代的地方
        　　所以我们可以调用它的next方法，获取下一个元素，并且在诶呦值可以返回的时候，生成器会自动产生Stoplteration异常

        状态挂起：

         　　生成器使用yield语句返回值。yield语句挂起该生成器函数的状态，保留足够的信息，以便之后从它离开的地方继续执行

12.用Python实现一个二分查找的函数

data = [1,3,6,7,9,12,14,16,17,18,20,22,23,25,33,32,35]

def binary_search(dataset,find_num):
    if len(dataset) > 1:
        mid = int(len(dataset) / 2)
        if dataset[mid] == find_num:  #找到数字
            print("找到数字"，dataset[mid])
        elif dataset[mid] > find_num: # 找的数在mid左边
            return binary_search(dataset[0:mid],find_num)
        else:
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0]  == find_num : # 找到数字
            print("找到数字"，dataset[0])
        else:
            print("要找的数字不在列表里")

 

13.谈谈你对闭包的理解？

　　外函数：函数A的内部定义了函数B，那么函数A就叫做外函数

　　内涵式：函数B就是内涵式

　　在一个外函数中定义了一个内函数，内函数里运用了外函数的临时变量，并且外函数的返回值是内函数的引用，这样就构成了一个闭包

14.os和sys模块的作用？

　　os:这个模块提供了一种方便的使用操作系统函数的方法

　　sys；这个模块可供访问由解释器使用或维护的变量和与解释器进行交互的函数

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

　　

import random
    random.randint(0,99)  #随机整数

    random.randrange(0,101,2) #0-100之间的偶数

    random.uniform(1,10) #浮点数

    random.choice('abc!@#$') #随机字符

    random.sample("abc!@#",3) #选取特定数量的字符

    random.shuffle([1,2,3,4,5]) #洗牌

 

16.如何使用python删除一个文件？

　　

import os
os.remove(path) #删除文件
os.rmdir(path)  #删除文件夹

 

17.谈谈你对面向对象的理解？

　　三大特性：封装，继承，多态
    　　封装：
        　　　　将我们的程序模块化，对象化，把具体事物的特性属性放到一个类里面，这就是封装
    　　继承：
        　　　　父类的属性可以被子类重复使用。
    　　多态：
        　　　　子类可以重写父类的方法

18.Python面向对象中的继承有什么特点？

　　继承的优点：
        　　建造系统中的类，避免重复操作
        　　新类经常是基于已经存在的类，这样就可以提升代码的复用程度
    　继承的特点：
        　　在继承中基类的构造（__init__()）方法不会被自动调用，它需要在其派生类的构造中亲自调用
        　　在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量
        　　Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。

19.面向对象中super的作用？

　　　super()函数是用于调用父类(超类)的一个方法
    　　super是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承会涉及到查找顺序，重复调用等种种问题

    　　在super机制里可以保证公共父类仅被执行一次，至于执行顺序，是按照方法解析顺序进行的

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

　　　functools用于高阶函数：指那些作用于函数或者返回其他函数的函数。通常情况下，只要是可以被当做函数调用的对象都是模块的目标

    　　把一个函数的某些参数给固定住，返回一个新的函数，调用这个新函数会更简单