面向对象总结

试题练习

一、

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

r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
x， 只写模式【不可读；不存在则创建，存在则报错】
a， 追加模式【可读； ? 不存在则创建；存在则只追加内容】
"+"
表示可以同时读写某个文件
r +， 读写【可读，可写】
w +，写读【可读，可写】
x + ，写读【可读，可写】
a +， 写读【可读，可写】
"b"
表示以字节的方式操作
rb
或
r + b
wb
或
w + b
xb或
w + b
ab或
a + b

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

s.strip("*")

3、用户输入一个任意数字n，求1 - n之间所有数字中的奇数

 

list（range(1,n,2)）

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

 

x = ''
for i in s:
    if i not in x:
        x += i
print(x)

 

5、

5.
a = 10
b = 20
def test5(a, b):
    print(a, b)
c = test5(b, a)
print(c)
上述代码中, 打印出来的值a, b, c分别是什么？为什么？



a 20
b 10  b，a 作为参数传进函数，对应值为参数b和a，所以对应值是20,10
c None    c为函数test（）的返回值接收者，因为函数没有返回值，所以为None

6、s = '123.33sdhf3424.34fdg323.324', 计算字符串中所有数字的和

本题结果应为：123.33 + 3424.34 + 323.32

s = '123.33sdhf3424.34fdg323.324'
import re
l = []
ret = re.findall('\d+\.\d{2}',s)
sum = 0
for i in ret:
   sum += eval(i)
print(sum)

7、 d = {'k1': 'v1', 'k2': [1, 2, 3], ('k', '3'): {1,2,3}}
请用程序实现：
1）输出上述字典中value为列表的key
2）如果字典中的key是一个元祖，请输出对应的value值。
3）d[('k', '3')]对应的value是一个什么数据类型

# (1) for key in d:
#     if type(d[key]) == list:
#         print(key)

# (2) for key in d:
#     if type(key) == tuple:
#         print(d[key])

# （3）集合

8、如果不使用 @ wrapper装饰器，请在a()之前加入一句代码，达到相同的效果

def wrapper(func):
    def inner(*arg, **kwargs):
        func(*arg, **kwargs)

    return inner

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

--------->
a = wrapper(a)
a()

 

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

# with open("7th_questions") as f:
#     for i in f:
#         if i.startswith("T")
#             print(i)

10、默写字符串对象的内置方法，越多越好

S.upper()   字母大写
S.lower()    字母小写
S.swapcase  # 大小写互换
S.istitle()  # 单词首字母是否大写的，且其它为小写（返回bool值）
S.strip()  # 默认可以去除左右多余的空白，括号内可填写选移除特定字符
S.split()  # 把字符串分割成list默认是空格分割可以指定分隔符号
S.index(字符)    返回括号中的字符在字符串中的索引
S.count（）   可以统计重复元素
S.replace('替换字符'，'替换后的字符')
S.center()  # 置于中央，左右两边可以设置宽度，可选参数是填充字符，默认是空格
S.endswith()  # 判断是否为结尾
S.startswith()  # 判断是否为开头
S.isspace()  # 判断判断是否为空格
S.ljust(50)  # 左对齐，可选参数填充符号
S.rjust(50)  # 右对

二、

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

#类 : 是对具有相同属性和相似行为的一类事物的抽象
#对象: 是一个具有具体属性值的类的实例化
#实例化 : 从一个抽象的类 变成(产生) 一个具体对象的过程
#实例: 就是对象

2.面向对象的三大特性是什么？

#继承 多态 封装

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

# 在类中的函数就是方法,描述的是一类事物的行为
# 方法 类方法 静态方法 私有方法 内置方法 属性方法(@property)

4.什么是属性？类中可以定义哪几种属性？

# 类 和 对象所拥有的的具体的"值"指标
# 私有属性 静态属性 动态属性(方法) 对象属性

 5.请简述类方法和静态方法有哪些区别？

# 装饰器不同 @staticmethod @classmethod
# 类方法中有一个默认的参数cls,而静态方法没有

 6.请简述新式类和经典类的区别？

#在py3里 所有的多继承问题 都符合 广度优先算法
#python3中的所有类 都默认继承object

#如果一个类 继承了object 这个类就被称为新式类
#没有继承object类 就被称为经典类

#深度优先 广度优先 都是一种遍历算法,把这个图中所有的项都走一遍,且不会重复

#经典类 遵循 深度优先算法 且没有mro方法  python2
#新式类 遵循 广度优先算法 有mro方法  py2 py3
#py3 super
#单继承中  super就是找父类
#多继承    super寻找的轨迹是根据mro(广度优先)顺序的

7.有一个类定义： 

class Person：
　　def __init__(self,name,age):
　　　　self.name = name
　　　　self.age = age

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

# obj_list = []
# for i in range(1, 11):
#     obj = Person("alex%s" % i, i)
#     obj_list.append(obj)
# print(obj_list)

2）求最高age的对象的name

# def func(obj):
#     return obj.age
# xx = max(obj_list, key=func)
# print(xx.name)

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

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

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

class Police:#定义一个警察类
　　def __init__(self,name,gande,wuqi,value=100,):#初始化对象传入参数
　　　　self.name=name#名字属性
　　　　self.gande=gande#伙，属性
　　　　self.wuqi=wuqi#武器属性
　　　　self.value=value#生命值属性
　　def ataik(self,name):#定义攻击方式
　　　　if not isinstance(name,Police):#如果不是警察
　　　　　　name.value-=10#坏人的血值减等于10
　　　　else:
　　　　　　print('友军')#否则是友军
class Terrorist:#定义一个匪徒的类
　　def __init__(self, name, gande, wuqi, value=100, ):#初始化对象
　　　　self.name = name#名字属性
　　　　self.gande = gande#伙属性
　　　　self.wuqi = wuqi#武器属性
　　　　self.value = value#生命值属性

　　def ataik(self, name):#攻击方式
　　　　if not isinstance(name, Terrorist):如果名字不是匪徒的类
　　　　name.value -= 10#警察的血值-=10
　　else:
　　　　print('友军')#否则是友军

9. 实例化一个警察，一个匪徒，警察攻击匪徒，匪徒掉血

p=Police('cris','man','m4a1')#实例化一个警察

t=Terrorist('alex','man','ak47')#实例化一个匪徒

p.ataik(t)#警察攻击匪徒
print(t.value)#显示匪徒的血值

class pepo:#定义一个人的类
    def __init__(self, name, gande, wuqi, value=100, ):#初始化方法
        self.name = name#name属性
        self.gande = gande#伙属性
        self.wuqi = wuqi#武器属性
        self.value = value#血值属性

class Police(pepo):#定义一个警察，继承人的类属性
    def ataik(self, name):#定义一个攻击方式
        if not isinstance(name,Police):#如果不是警察的类
            name.value-=10#匪徒的血值减等于10
    else:
        print('友军')#否则是友军

class Terrorist(pepo):#定义一个匪徒
    def ataik(self, name):#攻击方式
        if not isinstance(name,Terrorist):#如果不是匪徒的类
        name.value-=10#警察生命值减等于10
    else:
        print('友军') #否则是友军 

思考题：
有一个类的init方法如下：
class Person：
def __init__(self,name,age,sex,weight):
self.name = name
self.sex = sex
self.age = age
self.weight = weight
假设有100个person的对象，
若两个对象的obj1,obj2的name和sex属性相同
即obj1.name==obj2.name and obj1.sex==obj2.sex
我们认为两个对象为同一个对象，已知一个列表中的100个对象，对这100个对象进行去重。
提示：
重写Person类重的两个内置方法

class Person:#定义一个类
    def __init__(self,name,age,sex): #初始化属性
        self.name = name #对象的name属性
        self.age = age #对象的age属性
        self.sex = sex #对象的sex属性
    def __hash__(self): #定义哈希方法
        return hash('%s%s'%(self.name,self.sex)) #返回hash'self.name,self.sex'的值
    def __eq__(self, other): #定义一个eq方法
        if self.name == other.name and  \
            self.sex == other.sex: #如果对象属性等于
            return True
p_lst = [] #定义个空列表
for i in range(100):#打印0到99
    p_lst.append(Person('egon',i,'male'))#p_lst列表添加Person('egon',i,'male')
p_lst.append(Person('alex',i,'male'))#p_lst列表添加Person('alex',i,'male')
p_lst.append(Person('yuan',i,'male'))#p_lst列表添加Person('yuan',i,'male')
print(p_lst)
# print(set(p_lst)) # 报错不可hash 完成了__hash__
# hash是否相等   __hash__
# 值是否相等     __eq__
# a==b
# 收获1
# 对于一些python当中已经存在的内置函数 内置数据类型 内置模块中的方法
# 都有可能依赖于类中的内置方法
# 收获2
# set方法依赖集合中元素对象的__hash__ __eq__