20181214hw

面试题练习

1
1.以下程序输出结果是什么
 
a = 1
def fun(a):
    a = 2
fun(a)
print (a)  
 1
a = []
def fun(a):
    a.append(1)
fun(a)
print(a)
[ 1 ]

2.请简要说明什么是类变量，什么是实例变量，并观察以下程序的输出结果

 　　类变量：描述 
class Person:
    name="aaa"
p1=Person()
p2=Person()
p1.name="bbb"
print(p1.name)  
print(p2.name) 
print(Person.name) 
bbb
aaa
aaa

3.以下语句有什么弊端,name是元祖的时候，程序会是什么样的结果,如何避免

"hi there %s" % name
不是所有数据类型都可以作为字符串类型传参
运行异常
"hi there {}".format( name )

4.阅读下面的代码，写出A0，A1至An的最终值。

A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))

A1 = range(10)

A2 = [i for i in A1 if i in A0]

A3 = [A0[s] for s in A0]

A4 = [i for i in A1 if i in A3]

A5 = {i:i*i for i in A1}

A6 = [[i,i*i] for i in A1]

A0 = { 'a' = 1 , 'b' = 2 ,'c' = 3 , 'd' = 4 , 'e' = 5 }
A1 = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 ]
A2 = [ ]
A3 = [ 1 , 2 , 3 , 4 , 5 ]
A4 = [ 1 , 2 , 3 , 4 , 5 ]
A5 = { 1 , 4 , 9 , 16 , 25 , 36 , 49 , 64 , 81 }
A6 = [ [ 1 , 1 ] , [ 2 , 4 ] , [ 3 , 9 ] , [ 4 , 16 ] , [ 5 , 25 ] , [ 6 , 36 ] , [ 7 ,49 ] , [ 8 , 64 ] , [ 9 , 81 ] ]

5.你如何管理不同版本的代码？

 　　使用github进行项目管理

6.下面代码会输出什么：

def f(x,l=[]):
    for i in range(x):
        l.append(i*i)
    print(l）
f(2)
f(3,[3,2,1])
f(3)
[ 0 , 1 ]
[ 3 , 2 , 1 , 0 , 1 , 4 ]
[ 0 , 1 , 0 , 1 , 4 ]

7.这两个参数是什么意思：*args，**kwargs？我们为什么要使用它们？

 　　*args ： 可变参数

　　　　　　　　可传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple

　　**kwargs ：关键字参数

　　　　　　　　可传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

8.阅读下面的代码，它的输出结果是什么？

class A(object):
    def go(self):
        print "go A go!"
    def stop(self):
        print "stop A stop!"
    def pause(self):
        raise Exception("Not Implemented")
​
class B(A):
    def go(self):
        super(B, self).go()
        print "go B go!"
​
class C(A):
    def go(self):
        super(C, self).go()
        print "go C go!"
    def stop(self):
        super(C, self).stop()
        print "stop C stop!"
​
class D(B,C):
    def go(self):
        super(D, self).go()
        print "go D go!"
    def stop(self):
        super(D, self).stop()
        print "stop D stop!"
    def pause(self):
        print "wait D wait!"
class E(B,C): pass
a = A()
b = B()
c = C()
d = D()
e = E()
​
# 说明下列代码的输出结果
​
a.go()
b.go()
c.go()
d.go()
e.go()
go A go!
go A go!
go B go!
go A go!
go C go!
go A go!
go C go!
go B go!
go D go!
go A go!
go C go!
go B go!
a.stop()
b.stop()
c.stop()
d.stop()
e.stop()
stop A stop!
stop A stop!
stop A stop!
stop C stop!
stop A stop!
stop C stop!
stop D stop!
stop A stop!
stop C stop!
a.pause()
b.pause()
c.pause()
d.pause()
e.pause()

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

list1 = list( set( list1 ) )

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

单引号和双引号都可以用来表示一个字符串
单引号，双引号都用到包裹字符串，唯一不同用法在于如果字符串内有需要转义
的字符时候 ，单引号必须加反斜杠
3个引号还有一个特别棒的作用就是：加注释
如果出现换行必须采用反斜杠表明 易于书写阅读 但是输出还是没有换行的字符串
引用三引号 不仅可以分行输入字符串 而且输出显示也是分行的
python 三引号的形式用来输入多行文本,也就是说在三引号之间输入的内容将被原样保留,之中的单号和双引号不用转义,其中的不可见字符比如/n和/t都会被保留,这样的好处是你可以替换一些多行的文本
双引号内不用加反斜杠
单引号内必须加反斜杠
三单引号输入换行需要加单引号
三双引号最为完美，换行转义什么都不用加

11.写一个函数, 输入一个字符串, 返回倒序排列的结果

输入: string_reverse(‘abcdef') , 返回: ‘fedcba',写出你能想到的多种方法

str1 = input( ' Input a string : ' )
# 方法一
print( str1[ : : -1 ] )
# 方法二
l = list( str1 )
l.reverse()
print( ''.join( l ) )

 12. 单例模式（Singleton Pattern）是一种常用的软件设计模式，该模式的主要目的是确保某一个类只有一个实例存在。利用当前我们所学知识，尝试使得所创建的类是单实例模式

class Demo(): 
      count = 0 
      def test(self): 
          l = [] 
          def wrapper(self , *args ,**kw): 
              if len( l ) == 0: 
                  l.append( f( self , *args , **kw ) ) 
              return l[0] 
          return wrapper 
         
      @test 
      def __init__(self): 
             pass

编程练习

1.定义一个点（Point）类和直线（Line）类，使用 getLen 方法可以获得直线的长度。`?^$q=:dI

提示：

    • 设点 A(X1,Y1)、点 B(X2,Y2)，则两点构成的直线长度 |AB| = √((x1-x2)2+(y1-y2)2)
    • Python 中计算开根号可使用 math 模块中的 sqrt 函数
    • 直线需有两点构成，因此初始化时需有两个点（Point）对象作为参数
import math

class Point():
    def __init__( self , x , y ):
        self._x = x
        self._y = y

    def getX(self):
        return self._x

    def setX( self , x ):
        self._x = x

    def getY(self):
        return self._y
    
    def setY( self , y ):
        self._y = y 
    
    def point_info( self ):
        return ( self._x , self._y )


class Line():
    _points = []
    def __init__( self , point1 , point2 ):
        self._points.append( point1 )
        self._points.append( point2 )

    def setPoint( self , point , n ):
        self._points[ n - 1 ] = point

    def getPoint( self , n ):
        return self._points[ n -1 ]

    def getLen( self ):
        dx = self._points[ 0 ].getX() -self._points[ 1 ].getX()
        dy = self._points[ 0 ].getY() -self._points[ 1 ].getY()
        return math.sqrt( dx ** 2 + dy ** 2 )


p1 = Point( 1 , 1 )
p2 = Point( 2 , 2 )

l = Line( p1 , p2 )

print( l.getLen() )

2.列表[1,2,3,4,5],请使用map()函数输出[1,4,9,16,25]，并使用列表推导式提取出大于10的数，最终输出[16,25]

l = [ 1 , 2 , 3 , 4 , 5 ] 
l2 = []

g =  map( lambda i : i ** 2 , l ) 

for i in g:
    l2.append( i ) 

l3 = [ i for i in l2 if i > 10 ]
print( l2 )
print( l3 )

3.坦克

某次战役中，为便于信息交互，我军侦察部门将此次战役的关键高地坐标设定为（x=0，y=0）并规定，每向东增加100米，x加1，每向北增加100米，y加1。同时，我军情报部门也破译了敌军向坦克发送的指挥信号，其中有三种信号（L,R,M）用于控制坦克的运动，L 和 R 分别表示使令坦克向左、向右转向，M 表示令坦克直线开进100米，其它信号如T用于时间同步，P用于位置较准。

一日，我军侦察兵发现了敌军的一辆坦克，侦察兵立即将坦克所在坐标（P, Q）及坦克前进方向（W：西，E：东，N：北，S：南）发送给指挥部，同时启动信号接收器，将坦克接收到的信号实时同步发往指挥部，指挥部根据这些信息得以实时掌控了该坦克的位置，并使用榴弹炮精准地击毁了该坦克。

请设计合理的数据结构和算法，根据坦克接收到的信号，推断出坦克所在的位置。
设计时请考虑可能的扩展情况，并体现出您的设计风格。

假设，侦察兵发送给指挥部的信息如下：
坦克坐标：（11，39）
坦克运行方向：W
坦克接收到的信号为：MTMPRPMTMLMRPRMTPLMMTLMRRMP
其位置应该是（9，43），运动方向为E

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/TyroneYang/p/10119832.html