python1217作业

 

1.以下程序输出结果是什么

a = 1

def fun(a):

    a = 2

fun(a)

print (a)  

 

a = []

def fun(a):

    a.append(1)

fun(a)

print(a)

a = 1

a 为全局变量，函数里调用a与函数外定义的a没有关系了

a = [1]

列表为可变的，函数里更改列表，外面的列表也会改变

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

 

class Person:

    name="aaa"

p1=Person()

p2=Person()

p1.name="bbb"

print(p1.name)  

print(p2.name) 

print(Person.name) 

类的设计里：class里def外，通过变量名能被赋值，def里通过类对象即类名字的点运算变量名能被赋值
程序里：通过类对象的点运算类名也能被赋值

类的设计时：def里通过self点运算变量名能被赋值，不一定在init里，在其他方法里也行
　　　　　　通过实例对象的点运算也能赋值

输出结果分别为bbb，aaa，aaa，p1在类外重新赋值了，p2没有所以还是aaa，p3是类变量也是aaa

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

"hi there %s" % name
它无法同时传递一个变量和元祖
使用format可有效避免

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是一个可迭代的0:9的序列

A2：[0]

A3:[1,2,3,4,5]

A4:[1,2,3,4,5]

A5:{1:1,2:4,3:9,4:16,5:25}

A6:[[1:1],[2:4],[3:9],[4:16],[5:25]]

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)

f（2）为[0,1]
f(3,[3,2,1])为 [9,4,1]

f(3)为[0,1,4]

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

*args是变参
**kwargs是关键字参数
使用方便，好友就是不确定函数里要传递多少参数时，使用*args和**kwargs

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()

​

a.stop()

b.stop()

c.stop()

d.stop()

e.stop()

​

a.pause()

b.pause()

c.pause()

d.pause()

e.pause()

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！


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，c，e直接继承a.pause，所以结果一样。d.pause会返回一个wait d wait

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

 1 a = [1,2,5,3,4,4,5,3]
  2 b = []
  3 list(set(a))
  4 [b.append(h) for h in a if h not in b]
  5 print(b)
  6 b = [a[i] for i in range(len(a))  if a[i] not in a[0:i]]
  7 
  8 print(b)

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

单引号和双引号可以把一个内容以字符创形式赋予变量，单引号里不能加单引号，双引号里不能加双引号。
三引号里跟的是注释内容

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

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

  1 a = 'abcdef'
  2 a = sorted(a,reverse=True)
  3 a = ''.join(a)
  4 print(a)

a = 'abcdef'
 print(a[::-1])

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

 1 import functools
  2 def decorator(f):
  3     @functools.wraps(f)
  4     def wraps(*args,**kw):
  5         global p
  6         p += 1
  7         if p == 2:
  8             pass
  9         else:
 10             return f(*args,**kw)
 11     return wraps
 12 
 13 
 14 @ decorator
 15 class Lizi(object):
 16     count = 0
 17     def __init__(self,name):
 18         self.name = name
 19         Lizi.count += 1
 20         #if Lizi.count == 2:
 21             #return None
 22 
 23 p = 0
 24 diao = Lizi(3)
 25 print(diao.name)
 26 
 27 mao = Lizi(5)
 28 print(mao)
~              

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

提示：

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

 1 import math
  2 class Point(object):
  3     def __init__(self,x,y):
  4         self.x = x
  5         self.y = y
  6 
  7 
  8 
  9 class Line(object):
 10     def getline(self,m):
 11         r1 = m.y[0] - m.x [0]
 12         r2 = m.y[1] - m.x [1]
 13         p = r1 * r1 + r2 * r2
 14         return p
 15     def getLen(self,p):
 16         l = math.sqrt(p)
 17         return l
 18 m = Point([0,0],[3,4])
 19 l = Line()
 20 p = l.getline(m)
 21 l = l.getLen(p)
 22 print(l)

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

1 pp = [1,2,3,4,5]
  2 pk = map(lambda x: x ** 2,pp)
  3 l = list(pk)
  4 print(l)
  5 ll = [i for i in l if i > 10]
  6 print(ll)

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

class tanke(object):
    def __init__(self,P,Q,F):
        self.P = P
        self.Q = Q
        self.F = F
    def wei(self,z):
        fx = self.F

        if z == 'R':
            if fx == 'W':
                fx = 'N'
            elif fx == 'N':
                fx = 'E'
            elif fx == 'E':
                fx = 'S'
            elif fx == 'S':
                fx = 'W'
        elif z == 'L':
            if fx == 'W':
                fx = 'S'
            elif fx == 'S':
                fx = 'E'
            elif fx == 'E':
                fx = 'N'
            elif fx == 'N':
                fx = 'W'
        elif z == 'M':
            if fx == 'W':
                self.P  -= 1
            elif fx == 'N':
                self.Q  += 1
            elif fx == 'E':
                self.P  += 1
            elif fx == 'S':
                self .Q  -= 1
        self.F  = fx
        return self.Q ,self .P ,self .F
tank1 = tanke (11,39,'W' )
xinhao = 'MTMPRPMTMLMRPRMTPLMMTLMRRMP'
for i in xinhao:
    print(tank1 .wei(i ))

print(tank1.P ,tank1 .Q ,tank1 .F )