很全的 Python 面试题

a = [ ]

def fun ( a ) :

a . append ( 1 )

fun ( a )

print a    # [1]

def foo ( x ) :

print “executing foo(%s)” % ( x )

class A ( object ) :

def foo ( self , x ) :

print “executing foo(%s,%s)” % ( self , x )

@ classmethod

def class_foo ( cls , x ) :

print “executing class_foo(%s,%s)” % ( cls , x )

@ staticmethod

def static_foo ( x ) :

print “executing static_foo(%s)” % x

a = A ( )

class Person :

name = “aaa”

p1 = Person ( )

p2 = Person ( )

p1 . name = “bbb”

print p1 . name    # bbb

print p2 . name    # aaa

print Person . name    # aaa

class Person :

name = [ ]

p1 = Person ( )

p2 = Person ( )

p1 . name . append ( 1 )

print p1 . name    # [1]

print p2 . name    # [1]

print Person . name    # [1]

>>> class MyClass ( ) :

. . .      def __init__ ( self ) :

. . .              self . __superprivate = “Hello”

. . .              self . _semiprivate = “, world!”

. . .

>>> mc = MyClass ( )

>>> print mc . __superprivate

Traceback ( most recent call last ) :

File “<stdin>” , line 1 , in < module >

AttributeError : myClass instance has no attribute ‘__superprivate’

>>> print mc . _semiprivate

, world !

>>> print mc . __dict_ _

{ ‘_MyClass__superprivate’ : ‘Hello’ , ‘_semiprivate’ : ‘, world!’ }

>>> def print_everything ( * args ) :

for count , thing in enumerate ( args ) :

. . .          print ‘{0}. {1}’ . format ( count , thing )

. . .

>>> print_everything ( ‘apple’ , ‘banana’ , ‘cabbage’ )

0. apple

1. banana

2. cabbage

>>> def table_things ( * * kwargs ) :

. . .      for name , value in kwargs . items ( ) :

. . .          print ‘{0} = {1}’ . format ( name , value )

. . .

>>> table_things ( apple = ‘fruit’ , cabbage = ‘vegetable’ )

cabbage = vegetable

apple = fruit

>>> def print_three_things ( a , b , c ) :

. . .      print ‘a = {0}, b = {1}, c = {2}’ . format ( a , b , c )

. . .

>>> mylist = [ ‘aardvark’ , ‘baboon’ , ‘cat’ ]

>>> print_three_things ( * mylist )

a = aardvark , b = baboon , c = cat

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

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

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

instances = { }

def getinstance ( ) :

if cls not in instances :

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

return instances [ cls ]

return getinstance

@ singleton

class MyClass :

. . .

# mysingleton.py

class My_Singleton ( object ) :

def foo ( self ) :

pass

my_singleton = My_Singleton ( )

# to use

from mysingleton import my_singleton

my_singleton . foo ( )

>>> a = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]

>>> b = filter ( lambda x : x > 5 , a )

>>> print b

>>> [ 6 , 7 ]

>>> a = map ( lambda x : x * 2 , [ 1 , 2 , 3 ] )

>>> list ( a )

[ 2 , 4 , 6 ]

>>> reduce ( lambda x , y : x * y , range ( 1 , 4 ) )

6

import copy

a = [ 1 , 2 , 3 , 4 , [ ‘a’ , ‘b’ ] ]    #原始对象

b = a    #赋值，传对象的引用

c = copy . copy ( a )    #对象拷贝，浅拷贝

d = copy . deepcopy ( a )    #对象拷贝，深拷贝

a . append ( 5 )    #修改对象a

a [ 4 ] . append ( ‘c’ )    #修改对象a中的[‘a’, ‘b’]数组对象

print ‘a = ‘ , a

print ‘b = ‘ , b

print ‘c = ‘ , c

print ‘d = ‘ , d

输出结果：

a =    [ 1 , 2 , 3 , 4 , [ ‘a’ , ‘b’ , ‘c’ ] , 5 ]

b =    [ 1 , 2 , 3 , 4 , [ ‘a’ , ‘b’ , ‘c’ ] , 5 ]

c =    [ 1 , 2 , 3 , 4 , [ ‘a’ , ‘b’ , ‘c’ ] ]

d =    [ 1 , 2 , 3 , 4 , [ ‘a’ , ‘b’ ] ]

def memo ( func ) :

cache = { }

def wrap ( * args ) :

if args not in cache :

cache [ args ] = func ( * args )

return cache [ args ]

return wrap

@ memo

def fib ( i ) :

if i < 2 :

return 1

return fib ( i – 1 ) + fib ( i – 2 )

def fib ( n ) :

a , b = 0 , 1

for _ in xrange ( n ) :

a , b = b , a + b

return b

l1 = [ ‘b’ , ‘c’ , ‘d’ , ‘b’ , ‘c’ , ‘a’ , ‘a’ ]

l2 = { } . fromkeys ( l1 ) . keys ( )

print l2

l1 = [ ‘b’ , ‘c’ , ‘d’ , ‘b’ , ‘c’ , ‘a’ , ‘a’ ]

l2 = list ( set ( l1 ) )

l2 . sort ( key = l1 . index )

print l2

l1 = [ ‘b’ , ‘c’ , ‘d’ , ‘b’ , ‘c’ , ‘a’ , ‘a’ ]

l2 = [ ]

[ l2 . append ( i ) for i in l1 if not i in l2 ]

class ListNode :

def __init__ ( self , x ) :

self . val = x

self . next = None

class Solution :

# @param a ListNode

# @return a ListNode

def swapPairs ( self , head ) :

if head != None and head . next != None :

next = head . next

head . next = self . swapPairs ( next . next )

next . next = head

return next

return head

items = [ ( ‘name’ , ‘earth’ ) , ( ‘port’ , ’80’ ) ]

dict2 = dict ( items )

dict1 = dict ( ( [ ‘name’ , ‘earth’ ] , [ ‘port’ , ’80’ ] ) )

dict1 = { } . fromkeys ( ( ‘x’ , ‘y’ ) , – 1 )

dict = { ‘x’ : – 1 , ‘y’ : – 1 }

dict2 = { } . fromkeys ( ( ‘x’ , ‘y’ ) )

dict2 = { ‘x’ : None , ‘y’ : None }

def _recursion_merge_sort2 ( l1 , l2 , tmp ) :

if len ( l1 ) == 0 or len ( l2 ) == 0 :

tmp . extend ( l1 )

tmp . extend ( l2 )

return tmp

else :

if l1 [ 0 ] < l2 [ 0 ] :

tmp . append ( l1 [ 0 ] )

del l1 [ 0 ]

else :

tmp . append ( l2 [ 0 ] )

del l2 [ 0 ]

return _recursion_merge_sort2 ( l1 , l2 , tmp )

def recursion_merge_sort2 ( l1 , l2 ) :

return _recursion_merge_sort2 ( l1 , l2 , [ ] )

def loop_merge_sort ( l1 , l2 ) :

tmp = [ ]

while len ( l1 ) > 0 and len ( l2 ) > 0 :

if l1 [ 0 ] < l2 [ 0 ] :

tmp . append ( l1 [ 0 ] )

del l1 [ 0 ]

else :

tmp . append ( l2 [ 0 ] )

del l2 [ 0 ]

tmp . extend ( l1 )

tmp . extend ( l2 )

return tmp

class ListNode :

def __init__ ( self , x ) :

self . val = x

self . next = None

def node ( l1 , l2 ) :

length1 , lenth2 = 0 , 0

# 求两个链表长度

while l1 . next :

l1 = l1 . next

length1 += 1

while l2 . next :

l2 = l2 . next

length2 += 1

# 长的链表先走

if length1 > lenth2 :

for _ in range ( length1 – length2 ) :

l1 = l1 . next

else :

for _ in range ( length2 – length1 ) :

l2 = l2 . next

while l1 and l2 :

if l1 . next == l2 . next :

return l1 . next

else :

l1 = l1 . next

l2 = l2 . next

def binarySearch ( l , t ) :

low , high = 0 , len ( l ) – 1

while low < high :

print low , high

mid = ( low + high ) / 2

if l [ mid ] > t :

high = mid

elif l [ mid ] < t :

low = mid + 1

else :

return mid

return low if l [ low ] == t else False

if __name__ == ‘__main__’ :

l = [ 1 , 4 , 12 , 45 , 66 , 99 , 120 , 444 ]

print binarySearch ( l , 12 )

print binarySearch ( l , 1 )

print binarySearch ( l , 13 )

print binarySearch ( l , 444 )

def qsort ( seq ) :

if seq == [ ] :

return [ ]

else :

pivot = seq [ 0 ]

lesser = qsort ( [ x for x in seq [ 1 : ] if x < pivot ] )

greater = qsort ( [ x for x in seq [ 1 : ] if x >= pivot ] )

return lesser + [ pivot ] + greater

if __name__ == ‘__main__’ :

seq = [ 5 , 6 , 78 , 9 , 0 , – 1 , 2 , 3 , – 65 , 12 ]

print ( qsort ( seq ) )

def    coinChange ( values , money , coinsUsed ) :

#values    T[1:n]数组

#valuesCounts   钱币对应的种类数

#money  找出来的总钱数

#coinsUsed   对应于目前钱币总数i所使用的硬币数目

for cents in range ( 1 , money + 1 ) :

minCoins = cents      #从第一个开始到money的所有情况初始

for value in values :

if value <= cents :

temp = coinsUsed [ cents – value ] + 1

if temp < minCoins :

minCoins = temp

coinsUsed [ cents ] = minCoins

print ( ‘面值为：{0} 的最小硬币数目为：{1} ‘ . format ( cents , coinsUsed [ cents ] ) )

if __name__ == ‘__main__’ :

values = [ 25 , 21 , 10 , 5 , 1 ]

money = 63

coinsUsed = { i : 0 for i in range ( money + 1 ) }

coinChange ( values , money , coinsUsed )

## 14 二叉树节点

class Node ( object ) :

def __init__ ( self , data , left = None , right = None ) :

self . data = data

self . left = left

self . right = right

tree = Node ( 1 , Node ( 3 , Node ( 7 , Node ( 0 ) ) , Node ( 6 ) ) , Node ( 2 , Node ( 5 ) , Node ( 4 ) ) )

## 15 层次遍历

def lookup ( root ) :

stack = [ root ]

while stack :

current = stack . pop ( 0 )

print current . data

if current . left :

stack . append ( current . left )

if current . right :

stack . append ( current . right )

## 16 深度遍历

def deep ( root ) :

if not root :

return

print root . data

deep ( root . left )

deep ( root . right )

if __name__ == ‘__main__’ :

lookup ( tree )

deep ( tree )

def maxDepth ( root ) :

if not root :

return 0

return max ( maxDepth ( root . left ) , maxDepth ( root . right ) ) + 1

def isSameTree ( p , q ) :

if p == None and q == None :

return True

elif p and q :

return p . val == q . val and isSameTree ( p . left , q . left ) and isSameTree ( p . right , q . right )

else :

return False

def rebuild ( pre , center ) :

if not pre :

return

cur = Node ( pre [ 0 ] )

index = center . index ( pre [ 0 ] )

cur . left = rebuild ( pre [ 1 : index + 1 ] , center [ : index ] )

cur . right = rebuild ( pre [ index + 1 : ] , center [ index + 1 : ] )

return cur

def deep ( root ) :

if not root :

return

deep ( root . left )

deep ( root . right )

print root . data

class Node ( object ) :

def __init__ ( self , data = None , next = None ) :

self . data = data

self . next = next

link = Node ( 1 , Node ( 2 , Node ( 3 , Node ( 4 , Node ( 5 , Node ( 6 , Node ( 7 , Node ( 8 , Node ( 9 ) ) ) ) ) ) ) ) )

def rev ( link ) :

pre = link

cur = link . next

pre . next = None

while cur :

tmp = cur . next

cur . next = pre

pre = cur

cur = tmp

return pre

root = rev ( link )

while root :

print root . data

root = root . next