python 面向对象exam复习

原创
2018/03/16 17:24
阅读数 292

 

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

 

 

展开阅读全文
打赏
0
1 收藏
分享
加载中
更多评论
打赏
0 评论
1 收藏
0
分享
返回顶部
顶部