原标题：常见Python面试题 — 手写代码系列

作者： Peace & Love

来自：https://blog.csdn.net/u013205877/article/details/77542837

1.如何反向迭代一个序列#如果是一个list,最快的方法使用reverse

tempList = [ 1, 2, 3, 4]

tempList.reverse()

forx intempList:

printx

#如果不是list,需要手动重排

templist = ( 1, 2, 3, 4)

fori inrange(len(templist) -1, -1, -1):

printtemplist[i]

2.如何查询和替换一个文本中的字符串#最简单的方法使用replace()

tempstr = "hello you hello python are you ok"

printtempstr.replace( "you", "python")

#还可以使用正则,有个sub()

tempstr = "hello you hello python are you ok"

importre

rex = r'(hello|Use)'

printre.sub(rex, "Bye",tempstr)

3.使用python实现单例模式#方法一:可以使用__new__方法

#在__new__方法中把类实例绑定到类变量_instance上，如果cls._instance为None表示该类还没有实例化过，实例化该类并返回。如果cls_instance不为None表示该类已实例化，直接返回cls_instance

classSingleTon(object):

def__new__(cls,*args,**kwargs):

ifnothasattr(cls, '_instance'):

cls._instance = object.__new__(cls,*args,**kwargs)

returncls._instance

classTestClass(SingleTon):

a = 1

test1 = TestClass()

test2 = TestClass()

printtest1.a,test2.a

test1.a= 2

printtest1.a,test2.a

printid(test1),id(test2)

#方法二:使用装饰器,建立过实例的就放到instances里面,下次建立的时候先检查里面有没有

defSingleTon(cls,*args,**kwargs):

instances = {}

printinstances

def_singleton():

ifcls notininstances:

instances[cls] = cls(*args,**kwargs)

printinstances

returninstances[cls]

return_singleton

@SingleTon

classLastClass(object):

a = 1

test1 = LastClass()

printtest1.a

test2 = LastClass()

printtest2.a

#方法三:使用__metaclass__(元类)关于元类看看这个吧;http://blog.jobbole.com/21351/

classSignalTon(type):

def__init__(cls,name,bases,dict):

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

cls._instance = None

def__call__(cls, *args, **kwargs):

ifcls._instance isNone:

cls._instance = super(SignalTon,cls).__call__(*args,**kwargs)

returncls._instance

classTestClass(object):

__metaclass__ = SignalTon

test1 = TestClass()

test2 = TestClass()

test1.a = 2

printtest1.a,test2.a

printid(test1),id(test2)

#方法四:共享属性 所谓单例就是所有的引用(实例，对象)拥有相同的属性和方法，同一个类的实例天生都会有相同的方法，那我们只需要保证同一个类所产生的实例都具有相同的属性。所有实例共享属性最简单直接的方法就是共享__dict__属性指向。

classSingleTon(object):

_state = {}

def__new__(cls, *args, **kwargs):

obj = object.__new__(cls,*args,**kwargs)

obj.__dict__ = cls._state

returnobj

classTestClass(SingleTon):

a = 1

test1 = TestClass()

test2 = TestClass()

printtest1.a,test2.a

test1.a = 2

printtest1.a,test2.a

printid(test1),id(test2)

#方法五:使用同一个模版

#写在mysingleton.py中

classMy_Singleton(object):

deffoo(self):

pass

my_singleton = My_Singleton()

#写在要使用这个实例的py文件里面,在不同的引用的地方都引用相同的实例,以此实现单例模式

frommysingleton importmy_singleton

my_singleton.foo()

4.重新实现str.strip()defrightStrip(tempStr,splitStr):

endindex = tempStr.rfind(splitStr)

whileendindex != -1andendindex == len(tempStr) - 1:

tempStr = tempStr[:endindex]

endindex = tempStr.rfind(splitStr)

returntempStr

defleftStrip(tempStr,splitStr):

startindex = tempStr.find(splitStr)

whilestartindex == 0:

tempStr = tempStr[startindex+ 1:]

startindex = tempStr.find(splitStr)

returntempStr

str = " H "

printstr

printleftStrip(str, ' ')

printrightStrip(str, ' ')

#输出

H

H

H

5.super的原理#阅读下面的代码，它的输出结果是什么？

classA(object):

def__init__(self):

print"enter A"

super(A, self).__init__() # new

print"leave A"

classB(object):

def__init__(self):

print"enter B"

super(B, self).__init__() # new

print"leave B"

classC(A):

def__init__(self):

print"enter C"

super(C, self).__init__()

print"leave C"

classD(A):

def__init__(self):

print"enter D"

super(D, self).__init__()

print"leave D"

classE(B, C):

def__init__(self):

print"enter E"

super(E, self).__init__() # change

print"leave E"

classF(E, D):

def__init__(self):

print"enter F"

super(F, self).__init__() # change

print"leave F"

#输出

enter F

enter E

enter B

enter C

enter D

enter A

leave A

leave D

leave C

leave B

leave E

leave F

非常棒的讲解:

http://www.cnblogs.com/lovemo1314/archive/2011/05/03/2035005.html

6.闭包

常用的装饰器就是闭包的一种

defmake_adder(addend):

defadder(addend):

returnaddend+addend

returnadder

P1 = make_adder( 5)

P2= make_adder( 4)

printp1( 10)

#输出15

printp2( 10)

#输出14

闭包(Closure)是词法闭包(Lexical Closure)的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外

http://www.cnblogs.com/ma6174/archive/2013/04/15/3022548.html

https://foofish.net/python-closure.html

7.给列表中的字典排序

list 对象 alist [{“name”:”a”,”age”:20},{“name”:”b”,”age”:30},{“name”:”c”,”age”:25}]按照 age 从大到小排序

alist = [{ "name": "a", "age": 20},{ "name": "b", "age": 30},{ "name": "c", "age": 25}]

alist.sort(key= lambda:x:-x.get( "age"))

printalist

8.合并两个列表排除重复元素

用简洁的方法合并alist = [‘a’,’b’,’c’,’d’,’e’,’f’]

blist = [‘x’,’y’,’z’,’e’,’f’]并且元素不能重复

alist = [ 'a', 'b', 'c', 'd', 'e', 'f']

blist = [ 'x', 'y', 'z', 'e', 'f']

defmerge_list(*args):

s = set()

fori inargs:

s = s.union(i)

print(s)

returns

merge_list(alist,blist)

9.打乱一个排好序的列表fromrandom importshuffle

alist = range( 10)

print(alist)

shuffle(alist)

print(alist)

10.简单的实现一个栈结构 stackclassStack(object):

def__init__(self):

self.value = []

defpush(self,x):

self.value.append(x)

defpop(self):

self.value.pop()

stack = Stack()

stack.push( 1)

stack.push( 2)

stack.push( 3)

print(stack.value)

stack.pop()

print(stack.value)

11.输入一个日期,返回时一年中的哪一天fromdatetime importdatetime

defwhich_day(year,month,day):

return(datetime(year,month,day)-datetime(year, 1, 1)).days+ 1

print(which_day( 2017, 1, 15))

###12.把字符串”k1:1|k2:2|k3:3”处理成 python 字典的形式:{k1:1,k2:2,k3:3}

defstring_to_dict(string):

d = {}

forkv instring.split( "|"):

k,v = kv.split( ":")

ifv.isdigit():

v=int(v)

d[k]=v

returnd

print(string_to_dict( "k1:1|k2:2|k3:3"))

13.判断输入的值是否在矩阵之中(杨氏矩阵)

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

#处理数组矩阵

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]]

defget_num(num,data=None):

whiledata:

ifnum > data[ 0][ -1]:

deldata[ 0]

elifnum

data = list(zip(*data))

deldata[ -1]

data = list(zip(*data))

else:

returnTrue

data.clear()

returnFalse

print(get_num( 18,arr))

不处理数组矩阵

使用 step-wise 线性搜索

defgetvalue(data,value):

m = len(data) -1

n = len(data[ 0]) -1

r = 0

c = n

whilec>= 0andr<=m:

ifvalue == data[r][c]:

returnTrue

elifvalue>data[r][c]:

r = r+ 1

else:

c = c -1

returnFalse

14.获取最大公约数(欧几里得算法)a= 25

b= 15

defmax_common(a,b):

whileb:

a,b=b,a%b

returna

详解:

https://blog.csdn.net/franktan2010/article/details/38229641

15.求两个数的最小公倍数(公式法)

两个数的乘积等于这两个数的 最大公约数与最小公倍数的积

a= 25

b= 15

defmin_common(a,b):

c= a*b

whileb:

a,b=b,a%b

returnc//a

详情:

https://zhidao.baidu.com/question/90232880

16.获取中位数

如果总数个数是奇数，按从小到大的顺序，取中间的那个数；如果总数个数是偶数个的话，按从小到大的顺序，取中间那两个数的平均数。

#计算中位数

defmediannum(num):

listnum = [num[i] fori inrange(len(num))]

listnum.sort()

lnum = len(num)

iflnum % 2== 1:

i = int((lnum + 1) / 2) -1

returnlistnum[i]

else:

i = int(lnum / 2) -1

return(listnum[i] + listnum[i + 1]) / 2

详情:

https://blog.csdn.net/qq_33363973/article/details/78773144

defmedin(data):

data.sort()

half = len(data)// 2

return(data[half]+data[~half])/ 2

l = [ 1, 3, 4, 53, 2, 46, 8, 42, 82]

print(median(l))

(完)

●编号510，输入编号直达本文返回搜狐，查看更多

责任编辑：