标签：cap join() 描述 readlines line 面向对象 [1] 两种 foo
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
标签：cap join() 描述 readlines line 面向对象 [1] 两种 foo
原文地址：http://www.cnblogs.com/gaoshengyue/p/7592605.html
