练习题|面向对象编程

 

1、面向对象三大特性，各有什么用处，说说你的理解。

 继承、封装、多态

继承解决代码重用问题节省代码；多态，增加了程序的灵活性、增加了程序可扩展性。就是不考虑对象的类型可直接去使用它、一个统一的接口用户可直接使用；

封装将属性隐藏起来，可设置为私有属性，就是说父类不想让子类覆盖自己的的方法就可定义为私有。明确的区分内外，控制外部对隐藏的属性的操作行为、隔离复杂度等。

 

2、类的属性和对象的属性有什么区别?

对象是类的实例，类是相同特征和技能的对象的抽象；同类的各个对象具有相同的属性和方法，只是属性值不同；

类的属性是在类加载的时候就已经分配了内存，所有实例化出的对象都共有此属性；而对象的属性是单个实例化的类。

类的属性：数据属性和函数属性，数据属性是所有对象共有的，函数属性是绑定给对象使用的

3、面向过程编程与面向对象编程的区别与应用场景?

面向过程编程是：复杂的问题流程化，进而简单化（一个复杂的问题，分成一个个小的步骤去实现，实现小的步骤将会非常简单）

面向过程：核心是过程二字，过程指的是解决问题的步骤，设计一条流水线，机械式的思维方式；优点：复杂的问题流程化，进而简单化；缺点：可扩展性差

面向对象：核心就是对象二字，对象就是特征与技能的结合体；优点：可扩展性强；缺点：编程复杂度高

应用场景：用户需求经常变化，互联网应用，游戏，企业内部应用

 

4、类和对象在内存中是如何保存的？

类和对象的属性：以字典的形式保存的。

 

5、什么是绑定到对象的方法、绑定到类的方法、解除绑定的函数、如何定义，如何调用，给谁用？有什么特性

绑定到对象的方法：在类内定义的没有被任何装饰器修饰的，会把自己当做第一个参数传进去；

绑定到类的方法：在类内定义的被装饰器classmethod修饰的方法。

非绑定方法:没有自动传值这么一说了，就类中定义的一个普通工具，对象和类都可以使用调用。

6、使用实例进行 获取、设置、删除 数据, 分别会触发类的什么私有方法

 class A(object):
     pass

 a = A()

 a["key"] = "val"
 a = a["key"]
 del a["key"]

 

class A(object):
    def __setitem__(self, key, value):
        self.__dict__[key] = value
    def __getitem__(self, item):
        # return self.__dict__[item]
        return self.__dict__.get(item)
    def __delitem__(self, key):
        del self.__dict__[key]
a = A()
a["key"] = "val"
print(a.__dict__)
# a = a["key"]
# print(a)
del a["key"]
print(a.__dict__)

#打印：
{'key': 'val'}
{}

 

 

7、python中经典类和新式类的区别

新式类和经典类，py2有区分 py3中都是新式类。经典类的深度优先，新式类的广度优先。

新式类都是广度优先：先从对象自己这去找，没有再去对象的类中找，然后再从左边第一个父中找.....

 

8、如下示例, 请用面向对象的形式优化以下代码

1、在没有学习类这个概念时，数据与功能是分离的
   def exc1(host,port,db,charset):
   conn=connect(host,port,db,charset)
   conn.execute(sql)
   return xxx
   def exc2(host,port,db,charset,proc_name)
   conn=connect(host,port,db,charset)
   conn.call_proc(sql)
   return xxx
   # 每次调用都需要重复传入一堆参数
   exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;')
   exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字')

class exc:
    def __init__(self,proc_name):
        self.host = '127.0.0.1'
        self.port = 3306
        self.db = 'db'
        self.charset = 'utf-8'
        self.proc_name = proc_name
ex = exc('储存名称')
ex1 = exc('储存名称2')
print(ex.__dict__)
print(ex1.__dict__)

#打印：
{'host': '127.0.0.1', 'port': 3306, 'db': 'db', 'charset': 'utf-8', 'proc_name': '储存名称'}
{'host': '127.0.0.1', 'port': 3306, 'db': 'db', 'charset': 'utf-8', 'proc_name': '储存名称2'}

 

9、示例1, 现有如下代码， 会输出什么：

class People(object):
      __name = "luffy"
      __age = 18

 p1 = People()
 print(p1.__name, p1.__age)

　　会报错：AttributeError: 'People' object has no attribute '__name'

class People(object):
    __name = "luffy"
    __age = 18
p1 = People()
#print(p1.__name, p1.__age)

print(People.__dict__)
print(p1._People__name,p1._People__age)

#打印：
{'__module__': '__main__', '_People__name': 'luffy', '_People__age': 18, '__dict__': <attribute '__dict__' of 'People' objects>, '__weakref__': <attribute '__weakref__' of 'People' objects>, '__doc__': None}
luffy 18

 

10、示例2, 现有如下代码， 会输出什么：

class People(object):
   def __init__(self):
       print('__init__')
   def __new__(cls, *args, **kwargs):
       print('__new__')
       return object.__new__(cls, *args, **kwargs)
People()

#打印：
__new__
__init__

 

11、请简单解释Python中 staticmethod（静态方法）和 classmethod（类方法）, 并分别补充代码执行下列方法。

class A(object):
   def foo(self, x):
       print("executing foo(%s, %s)" % (self,x))
   @classmethod
   def class_foo(cls, x):
       print("executing class_foo(%s, %s)" % (cls,x))
   @staticmethod
   def static_foo(x):
       print("executing static_foo(%s)" % (x))
a = A()

@classmethod（类方法）是在类内部定义的装饰器，成为绑定到类的方法 ，由类来调用；

@staticmethod（静态方法）成为非绑定方法，没有自动传值这么一说了，就类中定义的一个普通工具，对象和类都可以使用调用。

 

class A(object):
   def foo(self, x):
       print("executing foo(%s, %s)" % (self,x))
   @classmethod
   def class_foo(cls, x):
       print("executing class_foo(%s, %s)" % (cls,x))
   @staticmethod
   def static_foo(x):
       print("executing static_foo(%s)" % (x))
a = A()
print(A.class_foo) #是个绑定方法
A.class_foo(3)
A.static_foo(8)
a.static_foo(9)

#打印：
<bound method A.class_foo of <class '__main__.A'>>
executing class_foo(<class '__main__.A'>, 3)
executing static_foo(8)
executing static_foo(9)

 

12、请执行以下代码，解释错误原因，并修正错误。

class Dog(object):

   def __init__(self,name):
       self.name = name

   @property
   def eat(self):
       print(" %s is eating" %self.name)

d = Dog("ChenRonghua")
d.eat()#错误的
#改为：
d.eat

#打印：
ChenRonghua is eating

　　错误原因：@property 可将函数属性转化为数据属性

 

13、下面这段代码的输出结果将是什么？请解释。

class Parent(object):
   x = 1
class Child1(Parent):
   pass
class Child2(Parent):
   pass
print(Parent.x, Child1.x, Child2.x)
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)

##打印出：
# 1 1 1 继承自父类的类属性x，所以都一样，指向同一块内存地址
# 1 2 1 更改Child1，Child1的x指向了新的内存地址
# 3 2 3 更改Parent，Parent的x指向了新的内存地址

 

14、多重继承的执行顺序，请解答以下输出结果是什么？并解释。

class A(object):
   def __init__(self):
       print('A')
       super(A, self).__init__()
class B(object):
   def __init__(self):
       print('B')
       super(B, self).__init__()
class C(A):
   def __init__(self):
       print('C')
       super(C, self).__init__()
class D(A):
   def __init__(self):
       print('D')
       super(D, self).__init__()
class E(B, C):
   def __init__(self):
       print('E')
       super(E, self).__init__()
class F(C, B, D):
   def __init__(self):
       print('F')
       super(F, self).__init__()
class G(D, B):
   def __init__(self):
       print('G')
       super(G, self).__init__()
if __name__ == '__main__':
   g = G()  #G--D--A--B
   f = F()  #F--C--B--D--A
#可以print下
print(G.mro())
print(F.mro())

# G
# D
# A
# B
#
# F
# C
# B
# D
# A

  #[<class '__main__.G'>, <class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
  #[<class '__main__.F'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>]

15、请编写一段符合多态特性的代码.

import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractclassmethod
    def talk(self):
        pass
    
class People(Animal):
    def talk(self):
        print('say hello')
class Dog(Animal):
    def talk(self):
        print('say wangwang')
class Cat(Animal):
    def talk(self):
        print('say miaomiao')
people1 = People()
dog1 = Dog()
cat1 = Cat()
def func(animal):
    animal.talk()
func(people1)
func(dog1)
func(cat1)

#打印：
say hello
say wangwang
say miaomiao

 

16、很多同学都是学会了面向对象的语法，却依然写不出面向对象的程序，原因是什么呢？原因就是因为你还没掌握一门面向对象设计利器，即领域建模，请解释下什么是领域建模，以及如何通过其设计面向对象的程序？http://www.cnblogs.com/alex3714/articles/5188179.html 此blog最后面有详解

 

领域模型,顾名思义,就是需求所涉及的领域的一个建模,更通俗的讲法是业务模型。
    定义：
        需求到面向对象的桥梁
    作用：
        1.发掘重要的业务领域概念
        2.建立业务领域概念之间的关系 
    方法：
        从用例中找名词
    领域建模的三字经方法:找名词、加属性、连关系。
        参考：http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label15 
             http://www.cnblogs.com/linhaifeng/articles/7341318.html 

 

17、请写一个小游戏，人狗大站，2个角色，人和狗，游戏开始后，生成2个人，3条狗，互相混战，人被狗咬了会掉血，狗被人打了也掉血，狗和人的攻击力，具备的功能都不一样。注意，请按题14领域建模的方式来设计类。

 名词：人、狗；

 属性：人：攻击力（打）、生命值（血）； 狗：攻击力（咬）、生命值（血）

 连关系：人被狗咬了掉血；狗被人打了掉血；

class Animal():
    def __init__(self,name,life_value,aggresivity):
        self.name = name
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class People(Animal):
    camp = 'home'
    def __init__(self,name,life_value,aggresivity):
        super().__init__(name,life_value,aggresivity)
    def attack(self,enemy):
        super().attack(enemy)
        print('from home')
class Dog(Animal):
    camp = 'doghome'
    def attack(self,enemy):
        Animal.attack(self,enemy)
        print('from dog')
p1 = People('alex',100,70)
p2 = People('alen',200,50)
d1 = Dog('huahua',80,10)
d2 = Dog('heihei',70,20)
print(d1.life_value)
p1.attack(d1)
print(d1.life_value)

#打印：
80
from home
10

 

18、编写程序, 在元类中控制把自定义类的数据属性都变成大写.

class Mymeta(type):
    def __new__(cls,class_name, class_bases, class_dics):
        update_dic = {}
        for k,v in class_dics.items(): #for i in class_dics:
            if not callable(v) and not k.startswith("__"): #if not callable(class_dics[i]) and not i.startswith("__")
                update_dic[k.upper()] = v
            else:
                update_dic[k] = v
        return type.__new__(cls,class_name, class_bases, update_dic)
class Chinese(metaclass=Mymeta):
    country = "china"
    sex = 'male'
print(Chinese.__dict__)

#打印：

{'__module__': '__main__', 'COUNTRY': 'china', 'SEX': 'male', '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None}

 

19、编写程序, 在元类中控制自定义的类无需init方法.

 

class MyMeta(type):
    def __call__(self, *args, **kwargs):
        if args:
            raise TypeError("must be keyword argument")
        obj = object.__new__(self)
        for k, v in kwargs.items():
            obj.__dict__[k]=v
        return obj
class Chinese(metaclass=MyMeta):
    country = 'china'
    def talk(self):
        print('%s is talking'%self.name)
print(Chinese.__dict__)
p1 = Chinese(name='alex', age=18)
print(p1, p1.country)
print(p1.__dict__)
p1.talk()

#打印：
{'__module__': '__main__', 'country': 'china', 'talk': <function Chinese.talk at 0x00000000028117B8>, '__dict__': <attribute '__dict__' of 'Chinese' objects>, '__weakref__': <attribute '__weakref__' of 'Chinese' objects>, '__doc__': None}
<__main__.Chinese object at 0x000000000280FD30> china
{'name': 'alex', 'age': 18}
alex is talking

 

 

20、编写程序, 编写一个学生类, 要求有一个计数器的属性, 统计总共实例化了多少个学生.

class Student():
    __count = 0
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        Student.__count += 1

    def talk(self):
        print('%s is talking'%self.name)
    @staticmethod  #非绑定方法
    def tell_count():
        print('一共实例化了%s人'% Student.__count)
stu1 = Student('kris',22,'male')
stu2 = Student('wind',18,'female')
print(Student.tell_count)
Student.tell_count()
stu2.tell_count()

 

21、编写程序, A 继承了 B, 俩个类都实现了 handle 方法, 在 A 中的 handle 方法中调用 B 的 handle 方法

 

class B():
    def __init__(self):
        pass
    def handle(self):
        print('B正在吃')
class A(B):
    def handle(self):
        #B.handle(self)
        super().handle()
        #print('A正在吃')
a1 = A()
a1.handle()

 

22、编写程序, 如下有三点要求

e.g
{
    "egon":{"password":"123",'status':False,'timeout':0},
    "alex":{"password":"456",'status':False,'timeout':0},
}

1. 自定义用户信息数据结构， 写入文件, 然后读取出内容, 利用json模块进行数据的序列化和反序列化

2. 定义用户类，定义方法db，例如 执行obj.db可以拿到用户数据结构

3. 在该类中实现登录、退出方法, 登录成功将状态(status)修改为True, 退出将状态修改为False(退出要判断是否处于登录状态).密码输入错误三次将设置锁定时间(下次登录如果和当前时间比较大于10秒即不允许登录)

import json
import time
class User:
    def __init__(self, name, password):
        self.name = name
        self.password = password
        self.status = False
        self.timeout = 0

    @property
    def db(self):
        with open(self.name+'.txt', 'r', encoding='utf-8') as f:
            data = json.load(f)
        return data

    def save(self):
        obj={}
        obj[self.name]={'password':self.password,'status':self.status,'timeout':self.timeout}
        with open(self.name+'.txt', 'w', encoding='utf-8') as f:
            json.dump(obj,f)

    def login(self):
        with open(self.name+'.txt', 'r+', encoding='utf-8') as f:
            data = json.load(f)
            count = 0
            while count < 3:
                password = input('password>>:').strip()
                if password != data[self.name]['password']:
                    count += 1
                    continue
                else:
                    if data[self.name]['timeout'] != 0:
                        if time.time() - data[self.name]['timeout'] > 10:
                            print('不允许登录了！超时')
                            break
                        else:
                            data[self.name]['status'] = True
                            f.seek(0)
                            f.truncate()
                            json.dump(data, f)
                            print('----welcome----')
                            break
                    else:
                        data[self.name]['status'] = True
                        f.seek(0)
                        f.truncate()
                        json.dump(data, f)
                        print('----welcome----')
                        break

            else:
                data[self.name]['timeout']=time.time()
                f.seek(0)
                f.truncate()
                json.dump(data,f)


    def quit(self):
        with open(self.name+'.txt', 'r+', encoding='utf-8') as f:
            data = json.load(f)
            if data[self.name]['status'] == True:
                data[self.name]['status'] = False
                f.seek(0)
                f.truncate()
                json.dump(data, f)
            else:
                print('您是退出状态！')


# alex=User('alex','123')
# egon=User('egon','456')
# # alex.save()
# # egon.save()
# # print(alex.db)
# # print(egon.db)
# # alex.login()
# alex.quit()
# # egon.quit()
# print(alex.db)
# print(egon.db)

# alex.login()
# egon.login()

 

23、用面向对象的形式编写一个老师角色, 并实现以下功能, 获取老师列表, 创建老师、删除老师、创建成功之后通过 pickle 序列化保存到文件里，并在下一次重启程序时能
读取到创建的老师, 例如程序目录结构如下

|-- bin/
|   |-- main.py         程序运行主体程序(可进行菜单选择等)
|-- config/
|   |-- settings.py     程序配置(例如: 配置存储创建老师的路径相关等)
|-- db                  数据存储(持久化, 使得每次再重启程序时, 相关数据对应保留)
|   |-- teachers/          存储所有老师的文件
|   |-- ...                ...
|-- src/                程序主体模块存放
|   |-- __init__.py
|   |-- teacher.py      例如: 实现老师相关功能的文件
|   |-- group.py        例如: 实现班级相关的功能的文件
|-- manage.py           程序启动文件
|-- README.md           程序说明文件

24、根据23 题, 再编写一个班级类, 实现以下功能, 创建班级, 删除班级, 获取班级列表、创建成功之后通过 pickle 序列化保存到文件里，并在下一次重启程序时能
读取到创建的班级.

25、根据 23题, 编写课程类, 实现以下功能, 创建课程(创建要求如上), 删除课程, 获取课程列表

26、根据23 题, 编写学校类, 实现以下功能, 创建学校, 删除学校, 获取学校列表

27、通过23题, 它们雷同的功能, 是否可以通过继承的方式进行一些优化

伪代码
class Behavior(object):

    def fetch(self, keyword):
        通过 keyword 参数 查询出对应的数据列表

class School(Behavior):

    pass

class Teacher(Behavior):

    pass

s = School()
t = Teacher()

s.fetch("school")
t.fetch("teacher")

 详细见：

https://www.cnblogs.com/shengyang17/p/8901437.html