python--多种程序分析（2）

1.文件操作有哪些模式？请简述各模式的作用

r模式只读  w模式只写 a模式只添加   r+可读可写  w+可写可读  a+可读可添加   rb  二进制只读  wb 二进制只写   ab 二进制添加

2.s = '**hello,world!**'请使用strip方法去掉字符串两端的’*’号

第一种:
   s=s.strip('**')
第二种
   s=s.lstrip('**")
   s=s.rstrip('**')
  
3.用户输入一个任意数字n，求1-n之间所有数字中的奇数

li=[]
n=input('请输入一个数字')
n=int(n)
for i in range(1,n+1):        //范围1到n，range不取n所以是n+1
    if i%2==1:                     //取余看等于1是奇数
        li.append(i)              //是奇数添加进列表
print(li)

4.s = 'hskakhlkshfkskjakf',请去除s字符串中重复的字母

答：
s = 'hskakhlkshfkskjakf'
li=[]
for item in s:       
    if item not in li:             //循环字符串，如果这个字符不在列表中就添加进去
      li.append(item)
s=''                               //创建一个空字符串
for it in li:                        //循环这个列表中不重复的字符，因为没有才添加进列表所以不重复
    s+=it                        //这些字符串相加起来就是一整个字符串然后打印
print(s)

5.a=10
  b=20
  def test5(a,b):
     print(a,b)
  c = test(b,a)
  print(c)
  上述代码中,打印出来的值a,b,c分别是什么？为什么？
 
 答：test后面没有5无法调用这个函数有问题  如果有5的话，调用的时候是反着传的，b的值给了a所以是20，a的值给了b所以是10，这个函数没有返回值，所有c是none
 
6.s = '123.33sdhf3424.34fdg323.324',计算字符串中所有数字的和
  本题结果应为：123.33+3424.34+323.32
 
答：import re              
s = '123.33sdhf3424.34fdg323.324'               
v=re.findall('\d+.*?\d+',s)                     //用正则取数字
c=0
for item in v:            //循环出v然后变成浮点类型相加
    item =float(item) 
    c+=item
print(c)

7.d={'k1':'v1','k2’:[1,2,3],(‘k’,’3’):{1，2，3}}
  请用程序实现：
  1）输出上述字典中value为列表的key
 
  答：d={'k1':'v1','k2':[1,2,3],('k','3'):{1,2,3}}
for item in d:
    if type(d[item]) == list:                 //如果这个key的value类型是list的话就打印出来
        print(item)
  
  2）如果字典中的key是一个元祖，请输出对应的value值。
 
  答：d={'k1':'v1','k2':[1,2,3],('k','3'):{1,2,3}}
for item in d:
    if type(item) == tuple:            //方法同上，不过判断的是key
        print(d[item])
  
  3）d[('k','3')]对应的value是一个什么数据类型
 
  答：集合  set
 
 
8.如果不使用@wrapper装饰器，请在a()之前加入一句代码，达到相同的效果
def wrapper(func):
    def inner(*arg, **kwargs):
        func(*arg, **kwargs)
    return inner

@wrapper
def a(arg):
    print(arg)

a()

答：在a()之前加一句  a=wrapper(a)

9.请处理文件7th_questions,输出所有以'T'开头的行

f=open('7th_questions',encoding='utf-8',mode='r')
v=f.readlines()
for item in v:
    if item[0]=='T':
        print(item)

11 默写10个字符串对象的内置方法，描述它的作用

-strip()  #去括号去其他
-replace()  #替换
-upper()   #全变大写
-lower()  #变小写
-capitalize()  #首字母大写
-isdigit()  #判断是否数字
-split()  #分割
-join()   #迭代
-count()  #看一个字符在字符串出现多少次
-starswith()  #看第一个字符是否是
-input()  #输入一个字符

1.请简述类、对象、实例化、实例这些名词的含义

答：类：具有属性和方法的事物
对象：可以实实在在描述出来的有属性的事物
实例化：创造对象的过程
实例：将对象利用类的属性和方法创造出来出来

2.面向对象的三大特性是什么？（3分）
封装

继承

多态

3.什么是方法？类中可以定义哪几种方法？

答：类中的函数就是方法
def __init__（self）方法，对象属性 
def p（self）方法  可直接调用的方法

私有方法

类方法

静态方法

普通方法

4.什么是属性？类中可以定义哪几种属性？
类可以赋给对象或者自己本身可调用的值   静态属性和对象属性，私有属性
5.请简述类方法和静态方法有哪些区别？
类方法必须传一个类可以使用类属性，静态方法不必须传参不能用类属性
6.请简述新式类和经典类的区别？
pythong2中要用新式的话，就要传基类object，经典类不用
新式类是广度优先
经典类是深度优先
7.有一个类定义：
    class Person：
        def __init__(self,name,age):
            self.name = name
            self.age = age

1）初始化10个不同的对象

 v=Person('t',2)
v_1=Person('v',3)
v_2=Person('w',4)
v_3=Person('q',5)
v_4=Person('p',7)
v_5=Person('i',11)
v_6=Person('r',22)
v_7=Person('yy',33)
v_8=Person('oi',54)
v_9=Person('tt',123)

2）求最高age的对象的name

 d={'v':v,'v_1':v_1,'v_2':v_2,'v_3':v_3,'v_4':v_4,'v_5':v_5,
   'v_6':v_6,'v_7':v_7,'v_8':v_8,'v_9':v_9}
li=[0,1]
for item in d.values():                #设置一个列表前两个值是0，1
    if item.age >li[0]:              #循环字典的value，如果值比列表0索引值大，就替换，1索引的key值也替换
        li[0]=item.age
        li[1]=item
    else:
        pass
print(li[1].name)                  #最后列表1索引留下的ey名就是值最大的

8. 模拟cs游戏
 1）人物角色分为警察和匪徒两种，定义成两个类

所有的警察的角色都是police
  每个警察都有自己独有名字，生命值，武器，性别
  每个都可以开枪攻击敌人，切攻击目标不能是police

所有的警察的角色都是terrorist
  每个匪徒都有自己独有名字，生命值，武器，性别
  每个都可以开枪攻击敌人，切攻击目标不能是terrorist

答：

class Jing:
    def __init__(self,name,blood,wuqi,sex,aggr):
        self.name=name
        self.blood = blood
        self.wuqi = wuqi
        self.sex = sex
        self.aggr = aggr
        self.juese='police'
    def attack(self,fei):
        if fei.juese !='police':
            print('%s开枪打了%s'%(self.name,fei.name))
            fei.blood=fei.blood-self.aggr
class Fei:
    juese='feitu'
    def __init__(self,name,blood,wuqi,sex,aggr):
        self.name=name
        self.blood = blood
        self.wuqi = wuqi
        self.sex = sex
        self.aggr = aggr
        self.juese = 'terrorist'
    def attack(self,jing):
        if jing.juese != 'terrorist':
            print('%s开枪打了%s' % (self.name,jing.name))
            jing.blood = jing.blood - self.aggr

2）实例化一个警察，一个匪徒，警察攻击匪徒，匪徒掉血

class Jing:
    def __init__(self,name,blood,wuqi,sex,aggr):
        self.name=name
        self.blood = blood
        self.wuqi = wuqi
        self.sex = sex
        self.aggr = aggr
        self.juese='police'
    def attack(self,fei):
        if fei.juese !='police':
            print('%s开枪打了%s'%(self.name,fei.name))
            fei.blood=fei.blood-self.aggr
            print('%s掉血%s'%(fei.name,fei.blood))
class Fei:
    juese='feitu'
    def __init__(self,name,blood,wuqi,sex,aggr):
        self.name=name
        self.blood = blood
        self.wuqi = wuqi
        self.sex = sex
        self.aggr = aggr
        self.juese = 'terrorist'
    def attack(self,jing):
        if jing.juese != 'terrorist':
            print('%s开枪打了%s' % (self.name,jing.name))
            jing.blood = jing.blood - self.aggr
            print('%s掉血%s' % (jing.name,jing.blood))
wujing=Jing('wujing',20000,'冲锋枪','man',500)
feitu=Fei('feitu',20000,'小匕首','man',50)
wujing.attack(feitu)

3）提取警察类和匪徒类相似之处定义成一个父类，使用继承的方式减少代码重复

class Person:
    def __init__(self,name,blood,wuqi,sex,aggr):
        self.name=name
        self.blood = blood
        self.wuqi = wuqi
        self.sex = sex
        self.aggr = aggr
class Jing(Person):
    def __init__(self,name,blood,wuqi,sex,aggr):
        super().__init__(name,blood,wuqi,sex,aggr)
        self.juese='police'
    def attack(self,fei):
        if fei.juese !='police':
            print('%s开枪打了%s'%(self.name,fei.name))
            fei.blood=fei.blood-self.aggr
            print('%s掉血%s'%(fei.name,fei.blood))
class Fei(Person):
    juese='feitu'
    def __init__(self,name,blood,wuqi,sex,aggr):
       super().__init__(name,blood,wuqi,sex,aggr)
       self.juese = 'terrorist'
    def attack(self,jing):
        if jing.juese != 'terrorist':
            print('%s开枪打了%s' % (self.name,jing.name))
            jing.blood = jing.blood - self.aggr
            print('%s掉血%s' % (jing.name,jing.blood))
wujing=Jing('wujing',20000,'冲锋枪','man',500)
feitu=Fei('feitu',20000,'小匕首','man',50)
wujing.attack(feitu)

11 读代码

class Base:
    def f1(self):
        self.f2()

def f2(self):
        print('...')

class Foo(Base):
    def f2(self):
        print('9999')

obj = Foo()
obj.f1()

问题1:面向对象中的self指的什么？

答：指的是实例化的对象本身

问题2:运行结果并简述原因

答：实例化了一个obj，因为Foo的父类是Base所以，子类没有f1就用父类的f1，有f2就用子类的f2
然后obj调用了f1,在f1中因为self是对象本身，所以f1方法中调用了obj的f2，而因为继承的规则，不调用父类的f2，所以结果是9999