PYTHON 一些基础面试题目总结

1. Python是如何进行内存管理的？

答:从三个方面来说,一对象的引用计数机制,二垃圾回收机制,三内存池机制

一、对象的引用计数机制

Python内部使用引用计数，来保持追踪内存中的对象，所有对象都有引用计数。

引用计数增加的情况：

1，一个对象分配一个新名称

2，将其放入一个容器中（如列表、元组或字典）

引用计数减少的情况：

1，使用del语句对对象别名显示的销毁

2，引用超出作用域或被重新赋值

sys.getrefcount( )函数可以获得对象的当前引用计数

多数情况下，引用计数比你猜测得要大得多。对于不可变数据（如数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。

二、垃圾回收

1，当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。

2，当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。

三、内存池机制

python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。

1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。

2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的malloc。

3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

2. 什么是lambda函数？它有什么好处?

答：lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数

lambda函数：首要用途是指点短小的回调函数

lambda [arguments]:expression

>>> a=lambdax,y:x+y

>>> a(3,11)

3. Python里面如何实现tuple和list的转换？

答：直接使用tuple和list函数就行了，type()可以判断对象的类型

4. 请写出一段Python代码实现删除一个list里面的重复元素

答：

1,使用set函数，set(list)

2，使用字典函数，

>>>a=[1,2,4,2,4,5,6,5,7,8,9,0]

>>> b={}

>>>b=b.fromkeys(a)

>>>c=list(b.keys())

>>> c

5. 编程用sort进行排序，然后从最后一个元素开始判断

a=[1,2,4,2,4,5,7,10,5,5,7,8,9,0,3]

a.sort()

last=a[-1]

for i inrange(len(a)-2,-1,-1):

if last==a[i]:

del a[i]

else:last=a[i]

print(a)

6. Python里面如何拷贝一个对象？（赋值，浅拷贝，深拷贝的区别）

答：赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。

浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数}

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的deep.deepcopy()函数}

7. 介绍一下except的用法和作用？

答：try…except…except…[else…][finally…]

执行try下的语句，如果引发异常，则执行过程会跳到except语句。对每个except分支顺序尝试执行，如果引发的异常与except中的异常组匹配，执行相应的语句。如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。

try下的语句正常执行，则执行else块代码。如果发生异常，就不会执行

如果存在finally语句，最后总是会执行。

8. Python中pass语句的作用是什么？

答：pass语句不会执行任何操作，一般作为占位符或者创建占位程序，whileFalse:pass

9. 介绍一下Python下range()函数的用法？

答：列出一组数据，经常用在for in range()循环中

10. 如何用Python来进行查询和替换一个文本字符串？

答：可以使用re模块中的sub()函数或者subn()函数来进行查询和替换，

格式：sub(replacement, string[,count=0])（replacement是被替换成的文本，string是需要被替换的文本，count是一个可选参数，指最大被替换的数量）

>>> import re

>>>p=re.compile(‘blue|white|red’)

>>>print(p.sub(‘colour’,'blue socks and red shoes’))

colour socks and colourshoes

>>>print(p.sub(‘colour’,'blue socks and red shoes’,count=1))

colour socks and redshoes

subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量

11. Python里面match()和search()的区别？

答：re模块中match(pattern,string[,flags]),检查string的开头是否与pattern匹配。

re模块中research(pattern,string[,flags]),在string搜索pattern的第一个匹配值。

>>>print(re.match(‘super’, ‘superstition’).span())

(0, 5)

>>>print(re.match(‘super’, ‘insuperable’))

None

>>>print(re.search(‘super’, ‘superstition’).span())

(0, 5)

>>>print(re.search(‘super’, ‘insuperable’).span())

(2, 7)

12. 用Python匹配HTML tag的时候，<.*>和<.*?>有什么区别？

答：术语叫贪婪匹配( <.*> )和非贪婪匹配(<.*?> )

例如:

<div><span>test</span></div>

<.*> :<div><span>test</span></div>

<.*?> :<div>

13. Python里面如何生成随机数？

答：random模块

随机整数：random.randint(a,b)：返回随机整数x,a<=x<=b

random.randrange(start,stop,[,step])：返回一个范围在(start,stop,step)之间的随机整数，不包括结束值。

随机实数：random.random( ):返回0到1之间的浮点数

random.uniform(a,b):返回指定范围内的浮点数。

14. 有没有一个工具可以帮助查找python的bug和进行静态的代码分析？

答：PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告

Pylint是另外一个工具可以进行codingstandard检查

15. 如何在一个function里面设置一个全局的变量？

答：解决方法是在function的开始插入一个global声明：

def f()

global x

16. 单引号，双引号，三引号的区别

答：单引号和双引号是等效的，如果要换行，需要符号(\),三引号则可以直接换行，并且可以包含注释

如果要表示Let’s
Go 这个字符串

单引号：s4 = ‘Let\’s
go’

双引号：s5 = “Let’s go”

s6 = ‘I realy like“python”!’

这就是单引号和双引号都可以表示字符串的原因了

17. 如何用Python来发送邮件？

可以使用smtplib标准库。

以下代码可以在支持SMTP监听器的服务器上执行。

import sys, smtplib

fromaddr =raw_input(“From: “)

toaddrs = raw_input(“To: “).split(‘,’)

print “Enter message, end with ^D:”

msg = ”

while 1:

line = sys.stdin.readline()

if not line:

break

msg = msg + line

# 发送邮件部分

server = smtplib.SMTP(‘localhost’)

server.sendmail(fromaddr, toaddrs, msg)

server.quit()

18. Python如何实现单例模式？其他23种设计模式python如何实现？

Python有两种方式可以实现单例模式，下面两个例子使用了不同的方式实现单例模式：

1.

class Singleton(type):

def __init__(cls, name, bases, dict):

super(Singleton, cls).__init__(name, bases, dict)

cls.instance = None

def __call__(cls, *args,**kw):

if cls.instance is None:

cls.instance = super(Singleton, cls).__call__(*args, **kw)

return cls.instance

class MyClass(object):

__metaclass__ = Singleton

print MyClass()

print MyClass()

2. 使用decorator来实现单例模式

def singleton(cls):

instances = {}

def getinstance():

if cls not in instances:

instances[cls] = cls()

return instances[cls]

return getinstance

@singleton

class MyClass:

…

19. 华为一道编程

有两个序列a,b，大小都为n,序列元素的值任意整形数，无序；

要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。

1. 将两序列合并为一个序列，并排序，为序列Source

2. 拿出最大元素Big，次大的元素Small

3. 在余下的序列S[:-2]进行平分，得到序列max，min

4. 将Small加到max序列，将Big加大min序列，重新计算新序列和，和大的为max，小的为min。

Python代码

def mean( sorted_list ):

if not sorted_list:

return (([],[]))

big = sorted_list[-1]

small = sorted_list[-2]

big_list, small_list =mean(sorted_list[:-2])

big_list.append(small)

small_list.append(big)

big_list_sum =sum(big_list)

small_list_sum =sum(small_list)

if big_list_sum >small_list_sum:

return ( (big_list,small_list))

else:

return (( small_list,big_list))

tests = [ [1,2,3,4,5,6,700,800],

[10001,10000,100,90,50,1],

range(1, 11),

[12312, 12311, 232, 210,30, 29, 3, 2, 1, 1]

]

for l in tests:

l.sort()

print

print “Source List:\t”,l

l1,l2 = mean(l)

print “Result List:\t”,l1, l2

print “Distance:\t”,abs(sum(l1)-sum(l2))

print ‘-*’*40

输出结果

Python代码

Source List: [1, 2, 3, 4, 5, 6, 700, 800]

Result List: [1, 4, 5, 800] [2, 3, 6, 700]

Distance: 99

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 50, 90, 100, 10000, 10001]

Result List: [50, 90, 10000] [1, 100, 10001]

Distance: 38

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Result List: [2, 3, 6, 7, 10] [1, 4, 5, 8, 9]

Distance: 1

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 1, 2, 3, 29, 30, 210, 232, 12311, 12312]

Result List: [1, 3, 29, 232, 12311] [1, 2, 30, 210, 12312]

Distance: 21

20. python程序中文输出问题怎么解决？

方法一：

用encode和decode

如：

import os.path

import xlrd,sys

Filename=’/home/tom/Desktop/1234.xls’

if not os.path.isfile(Filename):

raise NameError,”%s is not a valid filename”%Filename

bk=xlrd.open_workbook(Filename)

shxrange=range(bk.nsheets)

print shxrange

for x in shxrange:

p=bk.sheets()[x].name.encode(‘utf-8′)

print p.decode(‘utf-8′)

方法二：

在文件开头加上

reload(sys)

sys.setdefaultencoding(‘utf8′)这2行，再试着运行一下

字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。

decode的作用是将其他编码的字符串转换成unicode编码，如str1.decode('gb2312')，表示将gb2312编码的字符串str1转换成unicode编码。

encode的作用是将unicode编码转换成其他编码的字符串，如str2.encode('gb2312')，表示将unicode编码的字符串str2转换成gb2312编码。

因此，转码的时候一定要先搞明白，字符串str是什么编码，然后decode成unicode，然后再encode成其他编码

代码中字符串的默认编码与代码文件本身的编码一致。

如：s='中文'

如果是在utf8的文件中，该字符串就是utf8编码，如果是在gb2312的文件中，则其编码为gb2312。这种情况下，要进行编码转换，都需要先用decode方法将其转换成unicode编码，再使用encode方法将其转换成其他编码。通常，在没有指定特定的编码方式时，都是使用的系统默认编码创建的代码文件。

如果字符串是这样定义：s=u'中文'

则该字符串的编码就被指定为unicode了，即python的内部编码，而与代码文件本身的编码无关。因此，对于这种情况做编码转换，只需要直接使用encode方法将其转换成指定编码即可。

如果一个字符串已经是unicode了，再进行解码则将出错，因此通常要对其编码方式是否为unicode进行判断：

isinstance(s,unicode) #用来判断是否为unicode

用非unicode编码形式的str来encode会报错

如何获得系统的默认编码？

#!/usr/bin/env python

#coding=utf-8

import sys

print sys.getdefaultencoding()

该段程序在英文WindowsXP上输出为：ascii

21. python代码得到列表list的交集与差集

交集

b1=[1,2,3]

b2=[2,3,4]

b3 = [val for val in b1if val in b2]

print b3

差集

b1=[1,2,3]

b2=[2,3,4]

b3 = [val for val in b1 if val not in b2]

print b3

差集实例

———-

#/bin/env python

# -*- coding:utf-8 -*-

f =open(‘C:\diff_dealer\excel.txt’)

excel = f.readlines()

f.close()

f= open(‘C:\diff_dealer\db.txt’)

db = f.readlines()

diff = [val for val in db if val not in excel]

f.close()

f =open(‘C:\diff_dealer\diff.txt’, ‘w’)

f.writelines(diff)

f.close()

print diff

22. 写一个简单的python
socket编程

python 编写server的步骤：

1第一步是创建socket对象。调用socket构造函数。如：

socket = socket.socket(family, type )

family参数代表地址家族，可为AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用于同一台机器上的进程间通信。

type参数代表套接字类型，可为SOCK_STREAM(流套接字)和SOCK_DGRAM(数据报套接字)。

2.第二步是将socket绑定到指定地址。这是通过socket对象的bind方法来实现的：

socket.bind( address )由AF_INET所创建的套接字，address地址必须是一个双元素元组，格式是(host,port)。host代表主机，port代表端口号。如果端口号正在使用、主机名不正确或端口已被保留，bind方法将引发socket.error异常。

3.第三步是使用socket套接字的listen方法接收连接请求。

socket.listen( backlog )

backlog指定最多允许多少个客户连接到服务器。它的值至少为1。收到连接请求后，这些请求需要排队，如果队列满，就拒绝请求。

4.第四步是服务器套接字通过socket的accept方法等待客户请求一个连接。

connection, address =socket.accept()

调用accept方法时，socket会时入“waiting”状态。客户请求连接时，方法建立连接并返回服务器。accept方法返回一个含有两个元素的元组(connection,address)。第一个元素connection是新的socket对象，服务器必须通过它与客户通信；第二个元素address是客户的Internet地址。

5. 第五步是处理阶段，服务器和客户端通过send和recv方法通信(传输数据)。服务器调用send，并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接收信息。调用recv 时，服务器必须指定一个整数，它对应于可通过本次方法调用来接收的最大数据量。recv方法在接收数据时会进入“blocked”状态，最后返回一个字符串，用它表示收到的数据。如果发送的数据量超过了recv所允许的，数据会被截短。多余的数据将缓冲于接收端。以后调用recv时，多余的数据会从缓冲区删除(以及自上次调用recv以来，客户可能发送的其它任何数据)。

6. 传输结束，服务器调用socket的close方法关闭连接。

python编写client的步骤：

1. 创建一个socket以连接服务器：socket= socket.socket( family, type )

2.使用socket的connect方法连接服务器。对于AF_INET家族,连接格式如下：

socket.connect((host,port) )

host代表服务器主机名或IP，port代表服务器进程所绑定的端口号。如连接成功，客户就可通过套接字与服务器通信，如果连接失败，会引发socket.error异常。

3. 处理阶段，客户和服务器将通过send方法和recv方法通信。

4. 传输结束，客户通过调用socket的close方法关闭连接。

下面给个简单的例子：

server.py

if __name__ =='__main__':

import socket

sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)

sock.bind(('localhost',8001))

sock.listen(5)

while True:

connection,address =sock.accept()

try:

connection.settimeout(5)

buf =connection.recv(1024)

if buf == '1':

connection.send('welcometo server!')

else:

connection.send('pleasego out!')

except socket.timeout:

print 'time out'

connection.close()

client.py

python 代码

if __name__ =='__main__':

import socket

sock =socket.socket(socket.AF_INET, socket.SOCK_STREAM)

sock.connect(('localhost',8001))

import time

time.sleep(2)

sock.send('1')

print sock.recv(1024)

sock.close()

在终端运行server.py，然后运行clien.py，会在终端打印“welcometo server!"。如果更改client.py的sock.

23. Python文件操作的面试题

1. 如何用Python删除一个文件？

使用os.remove(filename)或者os.unlink(filename);

2. Python如何copy一个文件？

shutil模块有一个copyfile函数可以实现文件拷贝

1：Python如何实现单例模式？

Python有两种方式可以实现单例模式，下面两个例子使用了不同的方式实现单例模式：

1.

class Singleton(type):

def __init__(cls, name, bases, dict):

super(Singleton, cls).__init__(name, bases, dict)

cls.instance = None

def __call__(cls, *args, **kw):

if cls.instance is None:

cls.instance = super(Singleton, cls).__call__(*args, **kw)

return cls.instance

class MyClass(object):

__metaclass__ = Singleton

print MyClass()

print MyClass()

2. 使用decorator来实现单例模式

def singleton(cls):

instances = {}

def getinstance():

if cls not in instances:

instances[cls] = cls()

return instances[cls]

return getinstance

@singleton

class MyClass:

…

2：什么是lambda函数？

Python允许你定义一种单行的小函数。定义lambda函数的形式如下：labmda参数：表达式lambda函数默认返回表达式的值。你也可以将其赋值给一个变量。lambda函数可以接受任意个参数，包括可选参数，但是表达式只有一个：

>>> g = lambda x, y: x*y

>>> g(3,4)

12

>>> g = lambda x, y=0, z=0: x+y+z

>>> g(1)

1

>>> g(3, 4, 7)

14

也能够直接使用lambda函数，不把它赋值给变量：

>>> (lambda x,y=0,z=0:x+y+z)(3,5,6)

14

如果你的函数非常简单，只有一个表达式，不包含命令，可以考虑lambda函数。否则，你还是定义函数才对，毕竟函数没有这么多限制。

3：Python是如何进行类型转换的？

Python提供了将变量或值从一种类型转换成另一种类型的内置函数。int函数能够将符合数学格式数字型字符串转换成整数。否则，返回错误信息。

>>> int(”34″)

34

>>> int(”1234ab”) #不能转换成整数

ValueError: invalid literal for int(): 1234ab

函数int也能够把浮点数转换成整数，但浮点数的小数部分被截去。

>>> int(34.1234)

34

>>> int(-2.46)

-2

函数°oat将整数和字符串转换成浮点数：

>>> float(”12″)

12.0

>>> float(”1.111111″)

1.111111

函数str将数字转换成字符：

>>> str(98)

‘98′

>>> str(”76.765″)

‘76.765′

整数1和浮点数1.0在python中是不同的。虽然它们的值相等的，但却属于不同的类型。这两个数在计算机的存储形式也是不一样。

4：Python如何定义一个函数

函数的定义形式如

下：

def <name>(arg1, arg2,… argN):

<statements>

函数的名字也必须以字母开头，可以包括下划线“ ”,但不能把Python的

关键字定义成函数的名字。函数内的语句数量是任意的，每个语句至少有

一个空格的缩进，以表示此语句属于这个函数的。缩进结束的地方，函数

自然结束。

下面定义了一个两个数相加的函数：

>>> def add(p1, p2):

print p1, “+”, p2, “=”, p1+p2

>>> add(1, 2)

1 + 2 = 3

函数的目的是把一些复杂的操作隐藏，来简化程序的结构，使其容易

阅读。函数在调用前，必须先定义。也可以在一个函数内部定义函数，内

部函数只有在外部函数调用时才能够被执行。程序调用函数时，转到函数

内部执行函数内部的语句，函数执行完毕后，返回到它离开程序的地方，

执行程序的下一条语句。

5：Python是如何进行内存管理的？

Python的内存管理是由Python得解释器负责的，开发人员可以从内存管理事务中解放出来，致力于应用程序的开发，这样就使得开发的程序错误更少，程序更健壮，开发周期更短

6：如何反序的迭代一个序列？howdo I iterate over a sequence in reverse order

如果是一个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]

<do something with x>

7：Python里面如何实现tuple和list的转换？

函数tuple(seq)可以把所有可迭代的(iterable)序列转换成一个tuple, 元素不变，排序也不变。

例如，tuple([1,2,3])返回(1,2,3),tuple(’abc’)返回(’a’.’b',’c').如果参数已经是一个tuple的话，函数不做任何拷贝而直接返回原来的对象，所以在不确定对象是不是tuple的时候来调用tuple()函数也不是很耗费的。

函数list(seq)可以把所有的序列和可迭代的对象转换成一个list,元素不变，排序也不变。

例如 list([1,2,3])返回(1,2,3),list(’abc’)返回['a', 'b', 'c']。如果参数是一个list,她会像set[:]一样做一个拷贝

8：Python面试题：请写出一段Python代码实现删除一个list里面的重复元素

可以先把list重新排序，然后从list的最后开始扫描，代码如下：

if List:

List.sort()

last = List[-1]

for i in range(len(List)-2, -1, -1):

if last==List[i]: del List[i]

else: last=List[i]

9：Python文件操作的面试题

1. 如何用Python删除一个文件？

使用os.remove(filename)或者os.unlink(filename);

2. Python如何copy一个文件？

shutil模块有一个copyfile函数可以实现文件拷贝

10：Python里面如何生成随机数？

标准库random实现了一个随机数生成器，实例代码如下：

import random

random.random()

它会返回一个随机的0和1之间的浮点数

11：如何用Python来发送邮件？

可以使用smtplib标准库。

以下代码可以在支持SMTP监听器的服务器上执行。

import sys, smtplib

fromaddr = raw_input(”From: “)

toaddrs = raw_input(”To: “).split(’,')

print “Enter message, end with ^D:”

msg = ”

while 1:

line = sys.stdin.readline()

if not line:

break

msg = msg + line

# 发送邮件部分

server = smtplib.SMTP(’localhost’)

server.sendmail(fromaddr, toaddrs, msg)

server.quit()

12：Python里面如何拷贝一个对象？

一般来说可以使用copy.copy()方法或者copy.deepcopy()方法，几乎所有的对象都可以被拷贝

一些对象可以更容易的拷贝，Dictionaries有一个copy方法：

newdict = olddict.copy()

13：有没有一个工具可以帮助查找python的bug和进行静态的代码分析？

有，PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告

Pylint是另外一个工具可以进行coding standard检查。

14：如何在一个function里面设置一个全局的变量？

解决方法是在function的开始插入一个global声明：

def f()

global x

14：有两个序列a,b，大小都为n,序列元素的值任意整形数，无序；要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。

1. 将两序列合并为一个序列，并排序，为序列Source

2. 拿出最大元素Big，次大的元素Small

3. 在余下的序列S[:-2]进行平分，得到序列max，min

4. 将Small加到max序列，将Big加大min序列，重新计算新序列和，和大的为max，小的为min。

Python代码

def mean( sorted_list ):

if not sorted_list:

return (([],[]))

big = sorted_list[-1]

small = sorted_list[-2]

big_list, small_list = mean(sorted_list[:-2])

big_list.append(small)

small_list.append(big)

big_list_sum = sum(big_list)

small_list_sum = sum(small_list)

if big_list_sum > small_list_sum:

return ( (big_list, small_list))

else:

return (( small_list, big_list))

tests = [ [1,2,3,4,5,6,700,800],

[10001,10000,100,90,50,1],

range(1, 11),

[12312, 12311, 232, 210, 30, 29, 3, 2, 1, 1]

]

for l in tests:

l.sort()

print

print “Source List:\t”, l

l1,l2 = mean(l)

print “Result List:\t”, l1, l2

print “Distance:\t”, abs(sum(l1)-sum(l2))

print ‘-*’*40

输出结果

Python代码

Source List: [1, 2, 3, 4, 5, 6, 700, 800]

Result List: [1, 4, 5, 800] [2, 3, 6, 700]

Distance: 99

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 50, 90, 100, 10000, 10001]

Result List: [50, 90, 10000] [1, 100, 10001]

Distance: 38

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Result List: [2, 3, 6, 7, 10] [1, 4, 5, 8, 9]

Distance: 1

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

Source List: [1, 1, 2, 3, 29, 30, 210, 232, 12311, 12312]

Result List: [1, 3, 29, 232, 12311] [1, 2, 30, 210, 12312]

Distance: 21

-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*

15：用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>

<.*>这种匹配称作贪心匹配 <.*?>称作非贪心匹配

16：Python里面search()和match()的区别？

match（）函数只检测RE是不是在string的开始位置匹配， search()会扫描整个string查找匹配, 也就是说match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回none

例如：

print(re.match(’super’, ’superstition’).span())会返回(0,5)

而print(re.match(’super’, ‘insuperable’))则返回None

search()会扫描整个字符串并返回第一个成功的匹配

例如：print(re.search(’super’, ’superstition’).span())返回(0, 5)

print(re.search(’super’, ‘insuperable’).span())返回(2,7)

17：如何用Python来进行查询和替换一个文本字符串？

可以使用sub()方法来进行查询和替换，sub方法的格式为：sub(replacement, string[, count=0])

replacement是被替换成的文本

string是需要被替换的文本

count是一个可选参数，指最大被替换的数量

例子：

import re

p = re.compile(’(blue|white|red)’)

print(p.sub(’colour’,'blue socks and red shoes’))

print(p.sub(’colour’,'blue socks and red shoes’, count=1))

输出：

colour socks and colour shoes

colour socks and red shoes

subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量

例如：

import re

p = re.compile(’(blue|white|red)’)

print(p.subn(’colour’,'blue socks and red shoes’))

print(p.subn(’colour’,'blue socks and red shoes’, count=1))

输出

(’colour socks and colour shoes’, 2)

(’colour socks and red shoes’, 1)

18：介绍一下except的用法和作用？

Python的except用来捕获所有异常， 因为Python里面的每次错误都会抛出 一个异常，所以每个程序的错误都被当作一个运行时错误。

一下是使用except的一个例子：

try:

foo = opne(”file”) #open被错写为opne

except:

sys.exit(”could not open file!”)

因为这个错误是由于open被拼写成opne而造成的，然后被except捕获，所以debug程序的时候很容易不知道出了什么问题

下面这个例子更好点：

try:

foo = opne(”file”) # 这时候except只捕获IOError

except IOError:

sys.exit(”could not open file”)

19：Python中pass语句的作用是什么？

pass语句什么也不做，一般作为占位符或者创建占位程序，pass语句不会执行任何操作，比如：

while False:

pass

pass通常用来创建一个最简单的类：

class MyEmptyClass:

pass

pass在软件设计阶段也经常用来作为TODO，提醒实现相应的实现，比如：

def initlog(*args):

pass #please implement this

20：介绍一下Python下range()函数的用法？

如果需要迭代一个数字序列的话，可以使用range()函数，range()函数可以生成等差级数。

如例：

for i in range(5)

print(i)

这段代码将输出0, 1, 2, 3, 4五个数字

range(10)会产生10个值， 也可以让range()从另外一个数字开始，或者定义一个不同的增量，甚至是负数增量

range(5, 10)从5到9的五个数字

range(0, 10, 3) 增量为三， 包括0,3,6,9四个数字

range(-10, -100, -30) 增量为-30， 包括-10, -40, -70

可以一起使用range()和len()来迭代一个索引序列

例如：

a = ['Nina', 'Jim', 'Rainman', 'Hello']

for i in range(len(a)):

print(i, a[i])

拿网络上关于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)
详细转换总结如下:

函数                      描述
int(x [,base])              将x转换为一个整数
long(x [,base] )            将x转换为一个长整数
float(x)                    将x转换到一个浮点数
complex(real [,imag])       创建一个复数
str(x)                      将对象 x 转换为字符串
repr(x)                     将对象 x 转换为表达式字符串
eval(str)                   用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)                    将序列 s 转换为一个元组
list(s)                     将序列 s 转换为一个列表
set(s)                      转换为可变集合
dict(d)                     创建一个字典。d 必须是一个序列 (key,value)元组。
frozenset(s)                转换为不可变集合
chr(x)                      将一个整数转换为一个字符
unichr(x)                   将一个整数转换为Unicode字符
ord(x)                      将一个字符转换为它的整数值
hex(x)                      将一个整数转换为一个十六进制字符串
oct(x)                      将一个整数转换为一个八进制字符串
【题目: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，查找其中是否有某元素aalist = ['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)
【题目:046】|  介绍一下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>
【题目:047】|  Python列表与元组的区别是什么？分别在什么情况下使用？
Python中列表和元祖都是序列，因此都能进行添加，删除，更新，切片等操作。但列表是可变对象，元祖是不可变对象。
元祖主要用于函数赋值，字符串格式化等。但列表中的方法更多些，也是PYTHON中更常用的数据结构。
【题目:048】|  有一个长度是101的数组，存在1~100的数字，有一个是重复的，拿重复的找出来

# Python中，主要是拿count(i) ==2的找出来即可，再利用列表推导式
>>> l = [1, 2, 3, 4, 2]
>>> tmp = []
>>> [tmp.append(i) for i in l if l.count(i) == 2]
[None, None]
>>> tmp
[2, 2]
>>> set(tmp)
set([2])
【题目:049】|  set是在哪个版本成为build-in types的？举例说明,并说明为什么当时选择了set这种数据结构

python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算.

sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置或者插入点。因此，sets不支持 indexing, slicing, 或其它类序列（sequence-like）的操作。

下面来点简单的小例子说明。

>>> x = set('spam')
>>> y = set(['h','a','m'])
>>> x, y
(set(['a', 'p', 's', 'm']), set(['a', 'h', 'm']))

再来些小应用。

>>> x & y # 交集
set(['a', 'm'])

>>> x | y # 并集
set(['a', 'p', 's', 'h', 'm'])

>>> x - y # 差集
set(['p', 's'])

去除海量列表里重复元素，用hash来解决也行，只不过感觉在性能上不是很高，用set解决还是很不错的，示例如下：

>>> a = [11,22,33,44,11,22]
>>> b = set(a)
>>> b
set([33, 11, 44, 22])
>>> c = [i for i in b]
>>> c
[33, 11, 44, 22]

很酷把，几行就可以搞定。

1.8　集合

集合用于包含一组无序的对象。要创建集合，可使用set()函数并像下面这样提供一系列的项：
s = set([3,5,9,10])      #创建一个数值集合
t = set("Hello")         #创建一个唯一字符的集合

与列表和元组不同，集合是无序的，也无法通过数字进行索引。此外，集合中的元素不能重复。例如，如果检查前面代码中t集合的值，结果会是：

>>> t
set(['H', 'e', 'l', 'o'])
注意只出现了一个'l'。

集合支持一系列标准操作，包括并集、交集、差集和对称差集，例如：
a = t | s          # t 和 s的并集
b = t & s          # t 和 s的交集
c = t – s         # 求差集（项在t中，但不在s中）
d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）

基本操作：

t.add('x')            # 添加一项
s.update([10,37,42])  # 在s中添加多项

使用remove()可以删除一项：
t.remove('H')

len(s)
set 的长度

x in s
测试 x 是否是 s 的成员

x not in s
测试 x 是否不是 s 的成员

s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中

s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中

s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素

s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素

s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素

s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素

s.copy()
返回 set “s”的一个浅复制

请注意：union(), intersection(), difference() 和 symmetric_difference() 的非运算符（non-operator，就是形如 s.union()这样的）版本将会接受任何 iterable 作为参数。相反，它们的运算符版本（operator based counterparts）要求参数必须是 sets。这样可以避免潜在的错误，如：为了更可读而使用 set('abc') & 'cbs' 来替代 set('abc').intersection('cbs')。从 2.3.1 版本中做的更改：以前所有参数都必须是 sets。

另外，Set 和 ImmutableSet 两者都支持 set 与 set 之间的比较。两个 sets 在也只有在这种情况下是相等的：每一个 set 中的元素都是另一个中的元素（二者互为subset）。一个 set 比另一个 set 小，只有在第一个 set 是第二个 set 的 subset 时（是一个 subset，但是并不相等）。一个 set 比另一个 set 打，只有在第一个 set 是第二个 set 的 superset 时（是一个 superset，但是并不相等）。

子 set 和相等比较并不产生完整的排序功能。例如：任意两个 sets 都不相等也不互为子 set，因此以下的运算都会返回 False：a<b, a==b, 或者a>b。因此，sets 不提供 __cmp__ 方法。

因为 sets 只定义了部分排序功能（subset 关系），list.sort() 方法的输出对于 sets 的列表没有定义。

运算符
运算结果

hash(s)
返回 s 的 hash 值

下面这个表列出了对于 Set 可用二对于 ImmutableSet 不可用的运算：

运算符（voperator）
等价于
运算结果

s.update(t)
s |= t
返回增加了 set “t”中元素后的 set “s”

s.intersection_update(t)
s &= t
返回只保留含有 set “t”中元素的 set “s”

s.difference_update(t)
s -= t
返回删除了 set “t”中含有的元素后的 set “s”

s.symmetric_difference_update(t)
s ^= t
返回含有 set “t”或者 set “s”中有而不是两者都有的元素的 set “s”

s.add(x)

向 set “s”中增加元素 x

s.remove(x)

从 set “s”中删除元素 x, 如果不存在则引发 KeyError

s.discard(x)

如果在 set “s”中存在元素 x, 则删除

s.pop()

删除并且返回 set “s”中的一个不确定的元素, 如果为空则引发 KeyError

s.clear()

删除 set “s”中的所有元素

请注意：非运算符版本的 update(), intersection_update(), difference_update()和symmetric_difference_update()将会接受任意 iterable 作为参数。从 2.3.1 版本做的更改：以前所有参数都必须是 sets。

还请注意：这个模块还包含一个 union_update() 方法，它是 update() 方法的一个别名。包含这个方法是为了向后兼容。程序员们应该多使用 update() 方法，因为这个方法也被内置的 set() 和 frozenset() 类型支持。
【题目:050】| 说说decorator的用法和它的应用场景，如果可以的话，写一个decorator

所谓装饰器就是把函数包装一下，为函数添加一些附加功能，装饰器就是一个函数，参数为被包装的函数，返回包装后的函数：

def d(fp):
def _d(*arg, **karg):
print "do sth before fp.."
r= fp(*arg, **karg)
print "do sth after fp.."
return r
return _d

@d
def f():
print "call f"
#上面使用@d来表示装饰器和下面是一个意思
#f = d(f)

f()#调用f
【题目:051】| 写一个类，并让它尽可能多的支持操作符class Array:
__list = []

def __init__(self):
print "constructor"

def __del__(self):
print "destructor"

def __str__(self):
return "this self-defined array class"

def __getitem__(self, key):
return self.__list[key]

def __len__(self):
return len(self.__list)

def Add(self, value):
self.__list.append(value)

def Remove(self, index):
del self.__list[index]

def DisplayItems(self):
print "show all items----"
for item in self.__list:
print item

arr = Array()   #constructor
print arr    #this self-defined array class
print len(arr)   #0
arr.Add(1)
arr.Add(2)
arr.Add(3)
print len(arr)   #3
print arr[0]   #1
arr.DisplayItems()
#show all items----
#1
#2
#3
arr.Remove(1)
arr.DisplayItems()
#show all items----
#1
#3
#destructor
【题目:052】| 说一说你见过比较cool的python实现
cool的概念，角度不同，看法可能也就不同，个人觉得更Pythonic的代码就是最酷的代码。
【题目:053】| Python如何实现单例模式#-*- encoding=utf-8 -*-
print '----------------------方法1--------------------------'
#方法1,实现__new__方法
#并在将一个类的实例绑定到类变量_instance上,
#如果cls._instance为None说明该类还没有实例化过,实例化该类,并返回
#如果cls._instance不为None,直接返回cls._instance
class Singleton(object):
def __new__(cls, *args, **kw):
if not hasattr(cls, '_instance'):
orig = super(Singleton, cls)
cls._instance = orig.__new__(cls, *args, **kw)
return cls._instance

class MyClass(Singleton):
a = 1

one = MyClass()
two = MyClass()

two.a = 3
print one.a
#3
#one和two完全相同,可以用id(), ==, is检测
print id(one)
#29097904
print id(two)
#29097904
print one == two
#True
print one is two
#True

print '----------------------方法2--------------------------'
#方法2,共享属性;所谓单例就是所有引用(实例、对象)拥有相同的状态(属性)和行为(方法)
#同一个类的所有实例天然拥有相同的行为(方法),
#只需要保证同一个类的所有实例具有相同的状态(属性)即可
#所有实例共享属性的最简单最直接的方法就是__dict__属性指向(引用)同一个字典(dict)
#可参看:http://code.activestate.com/recipes/66531/
class Borg(object):
_state = {}
def __new__(cls, *args, **kw):
ob = super(Borg, cls).__new__(cls, *args, **kw)
ob.__dict__ = cls._state
return ob

class MyClass2(Borg):
a = 1

one = MyClass2()
two = MyClass2()

#one和two是两个不同的对象,id, ==, is对比结果可看出
two.a = 3
print one.a
#3
print id(one)
#28873680
print id(two)
#28873712
print one == two
#False
print one is two
#False
#但是one和two具有相同的（同一个__dict__属性）,见:
print id(one.__dict__)
#30104000
print id(two.__dict__)
#30104000

print '----------------------方法3--------------------------'
#方法3:本质上是方法1的升级（或者说高级）版
#使用__metaclass__（元类）的高级python用法
class Singleton2(type):
def __init__(cls, name, bases, dict):
super(Singleton2, cls).__init__(name, bases, dict)
cls._instance = None
def __call__(cls, *args, **kw):
if cls._instance is None:
cls._instance = super(Singleton2, cls).__call__(*args, **kw)
return cls._instance

class MyClass3(object):
__metaclass__ = Singleton2

one = MyClass3()
two = MyClass3()

two.a = 3
print one.a
#3
print id(one)
#31495472
print id(two)
#31495472
print one == two
#True
print one is two
#True

print '----------------------方法4--------------------------'
#方法4:也是方法1的升级（高级）版本,
#使用装饰器(decorator),
#这是一种更pythonic,更elegant的方法,
#单例类本身根本不知道自己是单例的,因为他本身(自己的代码)并不是单例的
def singleton(cls, *args, **kw):
instances = {}
def _singleton():
if cls not in instances:
instances[cls] = cls(*args, **kw)
return instances[cls]
return _singleton

@singleton
class MyClass4(object):
a = 1
def __init__(self, x=0):
self.x = x

one = MyClass4()
two = MyClass4()

two.a = 3
print one.a
#3
print id(one)
#29660784
print id(two)
#29660784
print one == two
#True
print one is two
#True
one.x = 1
print one.x
#1
print two.x
#1
【题目:054】| 如何用Python来发送邮件

# 可以使用smtplib标准库。
# 以下代码可以在支持SMTP监听器的服务器上执行。

import sys, smtplib

fromaddr = raw_input("From: ")
toaddrs  = raw_input("To: ").split(',')
print("Enter message, end with ^D:")
msg = ''
while 1:
line = sys.stdin.readline()
if not line:
break
msg += line

# 发送邮件部分
server = smtplib.SMTP('localhost')
server.sendmail(fromaddr, toaddrs, msg)
server.quit()
【题目:055】| Python自动连接ssh的代码

#!/usr/bin/env python

#import the need library.
import pxssh

#machine details
hostname = ''
username = ''
password = ''

#command we want to send
command = 'ls -lart'

#function to connect
def connect(hostname, username, password, release):
try:
s = pxssh.pxssh()
s.login(hostname, username, password, release)
print s
return s
except Exception, e:
print "[-] Error Connecting: " + str(e)

#func to send a command
def send_command(ssh_session, command):
ssh_session.sendline(command)
ssh_session.prompt()
print ssh_session.before

#main()
if __name__ == "__main__":
session = connect(hostname, username, password)
send_command(session, command)
或者用pexpect模块

#!/usr/bin/env python

import pexpect

def ssh_cmd(ip, passwd, cmd):
ret = -1
ssh = pexpect.spawn('ssh root@%s "%s"' % (ip, cmd))
try:
i = ssh.expect(['password:', 'continue connecting (yes/no)?'], timeout=5)
if i == 0 :
ssh.sendline(passwd)
elif i == 1:
ssh.sendline('yes\n')
ssh.expect('password: ')
ssh.sendline(passwd)
ssh.sendline(cmd)
res = ssh.read()
print res
ret = 0
except pexpect.EOF:
print "EOF"
ssh.close()
ret = -1
except pexpect.TIMEOUT:
print "TIMEOUT"
ssh.close()
ret = -2
return ret

#main()
if __name__ == "__main__":
ssh_cmd('127.0.0.1', 'password', 'ls -lart')
【题目:056】| 介绍一下Python Date Time方面的类
一.time模块
time模块提供各种操作时间的函数
一般有两种表示时间的方式:
第一种: 是时间戳的方式(相对于1970.1.1 00:00:00以秒计算的偏移量),时间戳是惟一的
第二种: 以数组的形式表示即(struct_time),共有九个元素，分别表示，同一个时间戳的struct_time会因为时区不同而不同

二.datetime模块
Python提供了多个内置模块用于操作日期时间，像calendar，time，datetime。time模块。
相比于time模块，datetime模块的接口则更直观、更容易调用。
datetime模块定义了下面这几个类：
datetime.date：表示日期的类。常用的属性有year, month, day；
datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond；
datetime.datetime：表示日期时间。
datetime.timedelta：表示时间间隔，即两个时间点之间的长度。
datetime.tzinfo：与时区有关的相关信息。
datetime中，表示日期时间的是一个datetime对象
datetime中提供了strftime方法，可以将一个datetime型日期转换成字符串：
【题目:057】| 写一个简单的Python socket编程
服务器端程序:
# FileName: server.py

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8001))

sock.listen(5)
while True:
conn, addr = sock.accept()
try:
conn.settimeout(5)
buff = conn.recv(1024)
if buff == '1':
conn.send('Hello, Client...')
else:
conn.send('Please, Go Out...')
except socket.timeout:
print 'Socket Time Out...'
finally:
conn.close()
客户端程序:
# FileName: client.py
import socket
import time

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8001))
time.sleep(2)
sock.send('1')
print sock.recv(1024)
sock.close()
在终端运行server.py，然后运行clien.py，会在终端打印“Hello, Client..."。
如果更改client.py的sock.send('1')为其它值在终端会打印“Please, Go Out...”。
更改time.sleep(2)为大于5的数值， 服务器将会超时。
【题目:058】| Tkinter的ToolTip控件

Tooltip控件是一个简单，但非常有用的控件。它能够为我们的软件提供非常漂亮的提示信息，提高软件的可用性，给用户比较好的体验。
假设现在有两个按钮，一个用来预览吊线世系图，一个用来预览行转。为了保持按钮文本的简洁，以及为按钮尺寸所限。
我们不能可能把这个按钮的主要功能通过text属性表述清楚，这个时候我们就可以用到tooltip控件了.
【题目:059】| 解释一下python的and-or语法
0 and ＊ 不需要再考虑＊是0还是1，结果是0
1 and ＊ 需要考虑＊是0还是1来决定结果。

1 or ＊ 不需要考虑后面的＊，结果为1
0 or ＊ 需要考虑后面的＊来决定结果

这个语法看起来类似于 C 语言中的 bool ? a : b 表达式。整个表达式从左到右进行演算，所以先进行 and 表达式的演算。 1 and 'first' 演算值为 'first'，然后 'first' or 'second' 的演算值为 'first'。

0 and 'first' 演算值为 False，然后 0 or 'second' 演算值为 'second'。

and-or主要是用来模仿 三目运算符 bool?a:b的，即当表达式bool为真，则取a否则取b。

and-or 技巧，bool and a or b 表达式，当 a 在布尔上下文中的值为假时，不会像 C 语言表达式 bool ? a : b 那样工作。
【题目:060】| Python里关于“堆”这种数据结构的模块是哪个？“堆”有什么优点和缺点这个真没有！
【题目:061】| 实现一个stack

class Stack :
def __init__( self ):
''''' Creates an empty stack. '''
self._items = list()

def isEmpty(self):
''''' Returns True if the stack is empty or False otherwise. '''
return len(self) == 0

def __len__(self):
''''' Returns the number of items in the stack. '''
return len(self._items)

def peek(self):
''''' Returns the top item on the stack without removing it. '''
assert not self.isEmpty(), "Cannot peek at an empty stack"
return self._items[-1]

def pop(self):
''''' Removes and returns the top item on the stack. '''
assert not self.isEmpty(), "Cannot pop from an empty stack"
return self._items.pop()

def push(self,item):
''''' Push an item onto the top of the stack. '''
self._items.append( item )
【题目:062】| 编写一个简单的ini文件解释器
db_config.ini
[code][baseconf]
host=127.0.0.1
port=3306
user=root
password=root
db_name=evaluting_sys
[concurrent]
processor=20

示例代码

import sys,os
import ConfigParser
def test(config_file_path):
cf = ConfigParser.ConfigParser()
cf.read(config_file_path)

s = cf.sections()
print 'section:', s

o = cf.options("baseconf")
print 'options:', o

v = cf.items("baseconf")
print 'db:', v

db_host = cf.get("baseconf", "host")
db_port = cf.getint("baseconf", "port")
db_user = cf.get("baseconf", "user")
db_pwd = cf.get("baseconf", "password")

print db_host, db_port, db_user, db_pwd

cf.set("baseconf", "db_pass", "123456")
cf.write(open("config_file_path", "w"))
if __name__ == "__main__":
test("../conf/db_config.ini")[/code]【题目:063】| 现有N个纯文本格式的英文文件，实现一种检索方案，即做一个小搜索引擎
【题目:064】| src = "security/afafsff/?ip=123.4.56.78&id=45"，请写一段代码用正则匹配出IP

import re

src = "security/afafsff/?ip=123.4.56.78&id=45"
m = re.search('ip=(\d{1,3}\.\d{1,3}\.\d{1,3}.\d{1,3})', src, re.S)  # re.S 改变'.'的行为
print m.group(1)
# 输出结果
>>>
123.4.56.78
【题目:064】| 已知仓库中有若干商品，以及相应库存，类似：袜子，10鞋子，20拖鞋，30项链，40要求随机返回一种商品，要求商品被返回的概率与其库存成正比。请描述实现的思路或者直接写一个实现的函数# -*- coding: utf-8 -*-
import random

Wa_Zhi     = ['WZ'] * 100
Xie_Zi     = ['XZ'] * 200
Tuo_Xie    = ['TX'] * 300
Xiang_Lian = ['XL'] * 400

All_Before = Wa_Zhi + Xie_Zi + Tuo_Xie + Xiang_Lian
All_After  = random.sample(All_Before, 100)
print All_After.count('WZ')
print All_After.count('XZ')
print All_After.count('TX')
print All_After.count('XL')

#输出结果，大致满足需求1: 2: 3: 4的比例
>>>
9
19
32
40