python 面试题1

电玩女神 2022-05-15 05:48 288阅读 0赞

标签：[python][] [面试题][Link 1]

拿网络上关于Python的面试题汇总了，给出了自认为合理的答案，有些题目不错，可以从中学到点什么，答案如不妥，请指正……

\+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

【**题目:001**】**|** 说说你对zen of python的理解，你有什么办法看到它?

Python之禅,Python秉承一种独特的简洁和可读行高的语法，以及高度一致的编程模式，符合“大脑思维习惯”，使Python易于学习、理解和记忆。Python同时采用了一条极简主义的设计理念，了解完整的Python哲学理念，可以在任何一个Python交互解释器中键入import this命令，这是Python隐藏的一个彩蛋:描绘了一系列Python设计原则。如今已是Python社区内流行的行话”EIBTI”，明了胜于晦涩这条规则的简称. 在Python的思维方式中，明了胜于晦涩，简洁胜于复杂。

>>> import this  
    The Zen of Python, by Tim Peters  
    
    Beautiful is better than ugly.  
    Explicit is better than implicit.  
    Simple is better than complex.  
    Complex is better than complicated.  
    Flat is better than nested.  
    Sparse is better than dense.  
    Readability counts.  
    Special cases aren't special enough to break the rules.  
    Although practicality beats purity.  
    Errors should never pass silently.  
    Unless explicitly silenced.  
    In the face of ambiguity, refuse the temptation to guess.  
    There should be one-- and preferably only one --obvious way to do it.  
    Although that way may not be obvious at first unless you're Dutch.  
    Now is better than never.  
    Although never is often better than *right* now.  
    If the implementation is hard to explain, it's a bad idea.  
    If the implementation is easy to explain, it may be a good idea.  
    Namespaces are one honking great idea -- let's do more of those!

【**题目:002**】**|** 说说你对pythonic的看法，尝试解决下面的小问题

\#简洁，明了，严谨，灵活

#交换两个变量值  
    a,b = b,a

\#去掉list中的重复元素 old\_list = \[1,1,1,3,4\] new\_list = list(set(old\_list)) \#翻转一个字符串 s = ‘abcde’ ss = s\[::-1\] \#用两个元素之间有对应关系的list构造一个dict names = \[‘jianpx’, ‘yue’\] ages = \[23, 40\] m = dict(zip(names,ages)) \#将数量较多的字符串相连，如何效率较高，为什么 fruits = \[‘apple’, ‘banana’\] result = ”.join(fruits) \#python字符串效率问题之一就是在连接字符串的时候使用‘+’号，例如 s = ‘s1’ + ‘s2’ + ‘s3’ + …+’sN’，总共将N个字符串连接起来， 但是使用+号的话，python需要申请N-1次内存空间， 然后进行字符串拷贝。原因是字符串对象PyStringObject在python当中是不可变 对象，所以每当需要合并两个字符串的时候，就要重新申请一个新的内存空间 （大小为两个字符串长度之和）来给这个合并之后的新字符串，然后进行拷贝。 所以用+号效率非常低。建议在连接字符串的时候使用字符串本身的方法 join（list），这个方法能提高效率，原因是它只是申请了一次内存空间， 因为它可以遍历list中的元素计算出总共需要申请的内存空间的大小，一次申请完。 【 **题目:003** 】 **|** 你调试python代码的方法有哪些?

具体IDE都有调试，比如:IDLE, Eclipse+Pydev都可以设置断点调试。 
    pdb模块也可以做调试。
    还有PyChecker和Pylint
    PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告  
    Pylint   是另外一个工具可以进行coding standard检查。

【 **题目:004** 】 **|** 你在github上都fork过哪些python库，列举一下你经常使用的，每个库用一句话描述下其功能

http://rogerdudler.github.io/git-guide/index.zh.html    #关于git简明指南  
    http://www.zhihu.com/question/20070065                  #关于git的BBS  
    http://www.techug.com/githug-for-designer               #关于github的

【 **题目:005** 】 **|** 什么是GIL?

什么是GIL(Global Interpreter Lock)全局解释器锁? 简单地说就是:
    每一个interpreter进程,只能同时仅有一个线程来执行, 获得相关的锁, 存取相关的资源.
    那么很容易就会发现,如果一个interpreter进程只能有一个线程来执行, 
    多线程的并发则成为不可能, 即使这几个线程之间不存在资源的竞争.
    从理论上讲,我们要尽可能地使程序更加并行, 能够充分利用多核的功能.

【 **题目:006**】 **|** 什么是元类(meta\_class)?

元类就是用来创建类的“东西”
    详情操作: http://blog.jobbole.com/21351/

【 **题目:007** 】 **|** 对比一下dict中items与iteritems?

>>> D = {'a':1,'b':2,'c':3,'d':4}  
    >>> D.items()                       #一次性取出所有  
    [('a', 1), ('c', 3), ('b', 2), ('d', 4)]  
    >>> D.iteritems()                   #迭代对象，每次取出一个。用for循环遍历出来；  
    <dictionary-itemiterator object at 0x00000000026243B8>  
    >>> for i in D.iteritems():  
    ...   print i,  
    ...  
    ('a', 1) ('c', 3) ('b', 2) ('d', 4)  
    >>> for k,v in D.iteritems():  
    ...   print k,  
    ...  
    a c b d  
    总结: 
    1. 一般iteritems()迭代的办法比items()要快，特别是数据库比较大时。
    2. 在Python3中一般取消前者函数

【 **题目:008** 】 **|** 是否遇到过python的模块间循环引用的问题，如何避免它?

这是代码结构设计的问题，模块依赖和类依赖
    如果老是觉得碰到循环引用，很可能是模块的分界线划错地方了。可能是把应该在一起的东西硬拆开了，可能是某些职责放错地方了，可能是应该抽象的东西没抽象
    总之微观代码规范可能并不能帮到太多，重要的是更宏观的划分模块的经验技巧，推荐uml，脑图，白板等等图形化的工具先梳理清楚整个系统的总体结构和职责分工
    
    采取办法，从设计模式上来规避这个问题，比如:
    1. 使用 “__all__” 白名单开放接口
    2. 尽量避免 import

【 **题目:009** 】 **|** 有用过with statement吗？它的好处是什么？

>>> with open('text.txt') as myfile:  
    ...   while True:  
    ...     line = myfile.readline()  
    ...     if not line:  
    ...       break  
    ...     print line,

\# with语句使用所谓的上下文管理器对代码块进行包装，允许上下文管理器实现一些设置和清理操作。 \# 例如：文件可以作为上下文管理器使用，它们可以关闭自身作为清理的一部分。 \# NOTE：在PYTHON2.5中，需要使用from \_\_future\_\_ import with\_statement进行with语句的导入 【 **题目:010**】 **|** 用Python生成指定长度的斐波那契数列

def fibs(x):
        result = [0, 1]
        for index in range(x-2):
            result.append(result[-2]+result[-1])
        return result
    
    if __name__=='__main__':
        num = input('Enter one number: ')
        print fibs(num)

【 **题目:011**】 **|** Python里如何生产随机数

>>> import random
    >>> random.random()
    0.29495314937268713
    >>> random.randint(1,11)
    8
    >>> random.choice(range(11))
    3

【 **题目:012**】 **|** Python里如何反序的迭代一个序列

如果是一个list, 最快的解决方案是：
    
    list.reverse()
    try:
        for x in list:
            “do something with x”
    finally:
        list.reverse()
    
    如果不是list, 最通用但是稍慢的解决方案是：
    for i in range(len(sequence)-1, -1, -1):
    x = sequence[i]

【 **题目:013**】 **|** Python中如何定义一个函数

def func(arg, *args, **kwagrs):   #普通函数
        func_body
        return 
    
    lambda x: x **2                   #匿名函数

【 **题目:014**】 **|** Python匹配HTML tag的时候，<.\*>和<.\*?>有什么区别

import re
    s = ‘<html><head><title>Title</title>’
    print(re.match(‘<.*>’, s).group())
    
    会返回一个匹配<html><head><title>Title</title>而不是<html>
    
    而
    
    import re
    s = ‘<html><head><title>Title</title>’
    print(re.match(‘<.*?>’, s).group())
    
    则会返回<html>
    
    <.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配

【 **题目:015**】 **|** Python里面search()和match()的区别

>>> import re
    >>> re.match(r'python','Programing Python, should be pythonic')
    >>> obj1 = re.match(r'python','Programing Python, should be pythonic')  #返回None
    >>> obj2 = re.search(r'python','Programing Python, should be pythonic') #找到pythonic
    >>> obj2.group()
    'python'

\#re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None； \#re.search匹配整个字符串，直到找到一个匹配。 【 **题目:016**】 **|** Python程序中文输出问题怎么解决

在Python3中，对中文进行了全面的支持，但在Python2.x中需要进行相关的设置才能使用中文。否则会出现乱码。
    Python默认采取的ASCII编码，字母、标点和其他字符只使用一个字节来表示，但对于中文字符来说，一个字节满足不了需求。
    为了能在计算机中表示所有的中文字符，中文编码采用两个字节表示。如果中文编码和ASCII混合使用的话，就会导致解码错误，从而才生乱码。
    解决办法:
    交互式命令中：一般不会出现乱码，无需做处理 
    py脚本文件中：跨字符集必须做设置，否则乱码
    1. 首先在开头一句添加:

\# coding = utf-8 \# 或 \# coding = UTF-8 \# 或 \# -\*- coding: utf-8 -\*- 2. 其次需将文件保存为UTF-8的格式！ 3. 最后: s.decode('utf-8').encode('gbk') 【 **题目:017**】 **|** 什么是lambda函数

函数使用:
    1. 代码块重复，这时候必须考虑到函数，降低程序的冗余度
    2. 代码块复杂，这时候必须考虑到函数，降低程序的复杂度
    Python有两种函数,一种是def定义，一种是lambda函数()
    当程序代码很短，且该函数只使用一次，为了程序的简洁，及节省变量内存占用空间，引入了匿名函数这个概念
    >>> nums = range(2,20)
    >>> for i in nums:
            nums = filter(lambda x:x==i or x % i,nums)
    >>> nums
    [2, 3, 5, 7, 11, 13, 17, 19]

【 **题目:018**】 **|** Python里面如何实现tuple和list的转换

#From list to Tuple                 
    tuple(a_list)

\#From Tuple to List def to\_list(t): return \[i if not isinstance(i,tuple) else to\_list(i) for i in t\] 【 **题目:019**】 **|** 请写出一段Python代码实现删除一个list里面的重复元素

>>> L1 = [4,1,3,2,3,5,1]
    >>> L2 = []
    >>> [L2.append(i) for i in L1 if i not in L2]
    >>> print L2
    [4, 1, 3, 2, 5]

【 **题目:020**】 **|** Python是如何进行类型转换的

>>> int('1234')                   # 将数字型字符串转为整形
    1234
    >>> float(12)                     # 将整形或数字字符转为浮点型
    12.0
    >>> str(98)                       # 将其他类型转为字符串型
    '98'
    >>> list('abcd')                  # 将其他类型转为列表类型
    ['a', 'b', 'c', 'd']
    >>> dict.fromkeys(['name','age']) # 将其他类型转为字典类型
    {'age': None, 'name': None}
    >>> tuple([1, 2, 3, 4])           # 将其他类型转为元祖类型
    (1, 2, 3, 4)

【 **题目:021**】 **|** 如何知道一个Python对象的类型

>>> type([]);type('');type(0);type({});type(0.0);type((1,))
    <type 'list'>
    <type 'str'>
    <type 'int'>
    <type 'dict'>
    <type 'float'>
    <type 'tuple'>

【**题目:022**】**|** Python里面如何拷贝一个对象

切片S[:]  # 注不能应用于字典
    深浅宝贝  # 能应用于所有序列和字典
    1. 浅拷贝D.copy()方法
    2. 深拷贝deepcopy(D)方法

【 **题目:023**】 **|** Python中pass语句的作用是什么

pass语句什么也不做,一般作为占位符或者创建占位程序

【 **题目:024**】 **|** 写一段程序逐行读入一个文本文件，并在屏幕上打印出来

f = open(filename)  
    while True:  
        line = f.readline()  
        if not line: break  
        print(line)  
    f.close()

【 **题目:025**】 **|** 如何用Python删除一个文件

import os
    os.remove(filename)

【 **题目:026**】 **|** Python代码得到列表list的交集与差集

>>> list1 = [1, 3, 4, 6]
    >>> list2 = [1, 2, 3, 4]
    >>> [i for i in list1 if i not in list2]
    [6]
    >>> [i for i in list1 if i in list2]
    [1, 3, 4]

【 **题目:027**】 **|** Python是如何进行内存管理的

python内部使用引用计数，来保持追踪内存中的对象，Python内部记录了对象有多少个引用，即引用计数，当对象被创建时就创建了一个引用计数，当对象不再需要时，这个对象的引用计数为0时，它被垃圾回收。所有这些都是自动完成，不需要像C一样，人工干预，从而提高了程序员的效率和程序的健壮性。

【 **题目:028**】 **|** 介绍一下Python下range()函数的用法

>>> range(10)
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> range(1, 10)
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    >>> range(0, 9, 2)
    [0, 2, 4, 6, 8]
    >>> range(99,0,-10)
    [99, 89, 79, 69, 59, 49, 39, 29, 19, 9]
    相区别的是xrange(),每次只取出一个迭代对象，如果是数据量比较大时，效率较高
    在Python3中，没有xrange()函数，其功能放在了range()函数上

【**题目:029**】**|** Python异常处理介绍一下

程序中出现异常情况时就需要异常处理。比如当你打开一个不存在的文件时。当你的程序中有
    一些无效的语句时，Python会提示你有错误存在。下面是一个拼写错误的例子，print写成了Print
    下面是异常最常见的几种角色
    1. 错误处理
    >>>可以在程序代码中捕捉和相应错误，或者忽略已发生的异常。
    >>>如果忽略错误，PYTHON默认的异常处理行为将启动:停止程序，打印错误信息。
    >>>如果不想启动这种默认行为，就用try语句来捕捉异常并从异常中恢复。
    2. 事件通知
    >>>异常也可用于发出有效状态的信号，而不需在程序间传递结果标志位。或者刻意对其进行测试
    3. 特殊情况处理
    >>>有时，发生了某种很罕见的情况，很难调整代码区处理。通常会在异常处理中处理，从而省去应对特殊情况的代码
    4. 终止行为
    >>>try/finally语句可确保一定会进行需要的结束运算，无论程序是否有异常
    5. 非常规控制流程

【 **题目:030**】 **|** 介绍一下Python中的filter方法

filter就像map,reduce,apply,zip等都是内置函数，用C语言实现，具有速度快，功能强大等
    
    优点。
    用于过滤与函数func()不匹配的值, 类似于SQL中select value != 'a'
    相当于一个迭代器，调用一个布尔函数func来迭代seq中的每个元素，返回一个是bool_seq返
    
    回为True的序列
    >>>第一个参数: function or None, 函数或None
    >>>第二个参数: sequence,序列

【 **题目:031**】 **|** 介绍一下except的用法和作用

try/except:          捕捉由PYTHON自身或写程序过程中引发的异常并恢复
    except:              捕捉所有其他异常
    except name:         只捕捉特定的异常
    except name, value:  捕捉异常及格外的数据(实例)
    except (name1,name2) 捕捉列出来的异常
    except (name1,name2),value: 捕捉任何列出的异常，并取得额外数据
    else:                如果没有引发异常就运行
    finally:             总是会运行此处代码

【 **题目:032**】 **|** 如何用Python来进行查询和替换一个文本字符串

>>> words = 'Python is a very funny language!'
    >>> words.find('Python')             # 返回的为0或正数时，为其索引号
    0
    >>> words.find('is')
    7
    >>> words.find('dafa')               # 返回-1表示查找失败
    -1
    >>> words.replace('Python', 'Perl')  # replace()替换
    'Perl is a very funny language!'

【 **题目:033**】 **|** Python如何copy一个文件

import shutil
    shutil.copyfile('a.py', 'copy_a.py')

【**题目:034**】**|** Python判断当前用户是否是root

import os
    if os.getuid() != 0:    # root账号的uid=0
        print os.getuid()
        print 'Should run as root account'
    else:
        print 'Hello, Root!'

【 **题目:035**】 **|** 用Python写一个for循环的例子

for循环可以遍历序列(列表，字符串，元祖),range()及迭代对象，如xrange()
    names = ['Alice', 'Betty', 'Fred', 'Tom']
    for index, name in enumerate(names):
        print 'index:',index,'=>', name

\# 输出结果 index: 0 => Alice index: 1 => Betty index: 2 => Fred index: 3 => Tom 【 **题目:036**】 **|** 介绍一下Python中webbrowser的用法

webbrowser模块提供了一个高级接口来显示基于Web的文档，大部分情况下只需要简单的调用open()方法。
    
    webbrowser定义了如下的异常：exception webbrowser.Error, 当浏览器控件发生错误是会抛出这个异常
    
    webbrowser有以下方法：
    
    webbrowser.open(url[, new=0[, autoraise=1]])
    
    这个方法是在默认的浏览器中显示url, 如果new = 0, 那么url会在同一个浏览器窗口下打开，如果new = 1, 会打开一个新的窗口，如果new = 2, 会打开一个新的tab, 如果autoraise ＝ true, 窗口会自动增长。
    
    webbrowser.open_new(url)
    在默认浏览器中打开一个新的窗口来显示url, 否则，在仅有的浏览器窗口中打开url
    
    webbrowser.open_new_tab(url)
    在默认浏览器中当开一个新的tab来显示url, 否则跟open_new()一样
    
    webbrowser.get([name]) 根据name返回一个浏览器对象，如果name为空，则返回默认的浏览器
    
    webbrowser.register(name, construtor[, instance])
    注册一个名字为name的浏览器，如果这个浏览器类型被注册就可以用get()方法来获取。

【 **题目:037**】 **|** 默写尽可能多的str对象的方法

#方法                                   #描述  
    -------------------------------------------------------------------------------------------------  
    S.capitalize()                          #返回首字母大写的字符串的副本  
    S.center(width[,fillchar])              #返回一个长度为max(len(S),width),S居中，两侧fillchar填充  
    S.count(sub[,start[,end]])              #计算子字符串sub的出现次数，可将搜索范围限制为S[start:end]  
    S.decode([encoding[,error]])            #返回使用给定编码方式的字符串的解码版本，由error指定错误处理方式  
    S.endswith(suffix[start[,end]])         #检查S是否以suffix结尾，可给定[start:end]来选择匹配的范围  
    S.expandtabs([tabsize])                 #返回字符串的副本，其中tab字符会使用空格进行扩展，可选择tabsize  
    S.find(sun[,start[,end]])               #返回子字符串sub的第一个索引，不存在则为-1,可选择搜索范围  
    S.index(sub[,start[,end]])              #返回子字符串sub的第一个索引，不存在则引发ValueError异常.  
    S.isalnum()                             #检查字符串是否由字母或数字字符组成  
    S.isalpha()                             #检查字符串是否由字母字符组成  
    S.isdigit()                             #检查字符串是否由数字字符组成  
    S.islower()                             #检查字符串是否由小写字母组成  
    S.isspace()                             #检查字符串是否由空格组成  
    S.istitle()                             #检查字符串时候首字母大写  
    S.isupper()                             #检查字符串是否由大写字母组成  
    S.join(sequence)                        #返回其中sequence的字符串元素由S连接的字符串  
    S.ljust(width[,fillchar])               #返回S副本左对齐的字符串,长度max(len(S),W),右侧fillchar填充  
    S.lower()                               #返回所有字符串都为小写的副本  
    S.lstrip([char])                        #向左移除所有char，默认移除(空格,tab,\n)  
    S.partition(seq)                        #在字符串中搜索seq并返回  
    S.replace(old,new[,max])                #将new替换olad,最多可替换max次  
    S.rfind(sub[,start[,end]])              #返回sub所在的最后一个索引，不存在则为-1,可定搜索范围S[start:end]  
    S.rindex(sub[,start[,end]])             #返回sub所在的最后一个索引，不存在则会引发ValueError异常。  
    S.rjust(width[,fillchar])               #返回S副本右对齐的字符串,长度max(len(S),W),左侧fillchar填充  
    S.rpartition(seq)                       #同Partition,但从右侧开始查找  
    S.rstip([char])                         #向右移除所有char，默认移除(空格,tab,\n)  
    S.rsplit(sep[,maxsplit])                #同split,但是使用maxsplit时是从右往左进行计数  
    S.split(sep[,maxsplit])                 #使用sep做为分割符,可使用maxsplit指定最大切分数  
    S.zfill(width)                          #在S的左侧以0填充width个字符  
    S.upper()                               #返回S的副本，所有字符大写  
    S.splitlines([keepends])                #返回S中所有行的列表，可选择是否包括换行符  
    S.startswith(prefix[,start[,end]])      #检查S是否以prefix开始，可用[start,end]来定义范围  
    S.strip([chars])                        #移除所有字符串中含chars的字符，默认移除(空格，tab,\n)  
    S.swapcase()                            #返回S的副本，所有大小写交换  
    S.title()                               #返回S的副本，所有单词以大写字母开头  
    S.translate(table[,deletechars])        #返回S的副本，所有字符都使用table进行的转换，可选择删除出现在deletechars中的所有字符

【 **题目:038**】 **|** 现在有一个dict对象adict,里面包含了一百万个元素,查找其中的某个元素的平均需要多少次比较

O(1)  哈希字典，快速查找，键值映射，键唯一!

【 **题目:039**】 **|** 有一个list对象alist，里面的所有元素都是字符串，编写一个函数对它实现一个大小写无关的排序

words = ['This','is','a','dog','!']
    words.sort(key=lambda x:x.lower())
    print words

\#输出结果 >>> \['!', 'a', 'dog', 'is', 'This'\] 【 **题目:040**】 **|** 有一个排好序地list对象alist，查找其中是否有某元素a

alist = ['a','s','d','f']
    
    try:
        alist.index('a')
        print 'Find it.'
    except ValueError:
        print 'Not Found.'

【 **题目:041**】 **|** 请用Python写一个获取用户输入数字，并根据数字大小输出不同信息的脚本

num = input('Enter number: ')
    
    if num > 100:
        print 'The number is over 100'
    elif 0 < num <= 100:
        print 'The number is between 0~100'
    elif num < 0:
        print 'The number is negative.'
    else:
        print 'Not a number'

【 **题目:042**】 **|** 打乱一个排好序的list对象alist

# random模块中的shuffle(洗牌函数)
    import random
    alist = [1, 2, 3, 4]
    random.shuffle(alist)   
    print alist

【 **题目:043**】 **|** 有二维的list对象alist，假定其中的所有元素都具有相同的长度，写一段程序根据元素的第二个元素排序

def sort_lists(lists, sord, idx):
        if sord == 'desc':
            lists.sort(key=lambda x:x[idx], reverse=True)
        else:
            lists.sort(key=lambda x:x[idx])
        return lists
    lists = [['cd','ab'],['ef','ac']]
    sort_lists(lists,'desc',1)
    print lists

\# 输出结果 >>> \[\['ef', 'ac'\], \['cd', 'ab'\]\] 【 **题目:044**】 **|** inspect模块有什么用

inspect模块提供了一系列函数用于帮助使用自省。
    
    检查对象类型
    is{module|class|function|method|builtin}(obj): 检查对象是否为模块、类、函数、方法、内建函数或方法。
    isroutine(obj): 用于检查对象是否为函数、方法、内建函数或方法等等可调用类型。
    
    获取对象信息
    getmembers(object[, predicate]): 这个方法是dir()的扩展版，它会将dir()找到的名字对应的属性一并返回。
    getmodule(object): 它返回object的定义所在的模块对象。
    get{file|sourcefile}(object): 获取object的定义所在的模块的文件名|源代码文件名（如果没有则返回None）。
    get{source|sourcelines}(object): 获取object的定义的源代码，以字符串|字符串列表返回。
    getargspec(func): 仅用于方法，获取方法声明的参数，返回元组，分别是(普通参数名的列表, *参数名, **参数名, 默认值元组)。

【 **题目:045**】 **|** Python处理命令行参数示例代码

# 最简单、最原始的方法就是手动解析了
    import sys
    for arg in sys.argv[1:]:
        print(arg)

【**题目:045**】**|** 介绍一下Python getopt模块

# getopt模块是原来的命令行选项解析器，支持UNIX函数getopt()建立的约定。

\# 它会解析一个参数序列，如sys.argv，并返回一个元祖序列和一个非选项参数序列。 \# 目前支持的选项语法包括短格式和长格式选项：-a, -bval, -b val, --noarg, --witharg=val, --witharg val。 \# 如果只是简单的命令行解析，getopt还是不错的选择。一个例子如下 import sys import getopt try: options, remainder = getopt.getopt(sys.argv\[1:\], 'o:v', \['output=', 'verbose', 'version=',\]) except getopt.GetoptError as err: print 'ERROR:', err sys.exit(1) 总结下getopt的特点：1. getopt是从前到后解析 2. getopt不检查额外参数的合法性，需要自行检查 3. 短命令行和长命令行是分开解析的</span>

[Python面试题汇总][Python]

标签：[python][] [面试题][Link 1]

原文地址：http://blog.csdn.net/jerry\_1126/article/details/44023949

[python]: http://www.mamicode.com/so/1/python
[Link 1]: http://www.mamicode.com/so/1/%e9%9d%a2%e8%af%95%e9%a2%98
[Python]: http://www.mamicode.com/info-detail-496924.html