zoukankan html css js c++ java

python 要掌握面向对象，你得会做这些题

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

继承：解决代码重用问题
 
多态：多态性，可以在不考虑对象类型的情况下而直接使用对象
 
封装：明确的区分内外，控制外部对隐藏属性的操作行为，隔离复杂度

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

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

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

面向过程：复杂的问题流程化，简单化
应用场景：不再需要扩展了，监测脚本，自动部署脚本，软件解压安装
 
面向对象：特征与技能的结合体 一切皆对象
应用场景：用户需求经常变化，互联网应用，游戏，企业内部应用

4，类和对象在内存中是如何保存的。

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

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

绑定到对象的方法：就应该由对象来调用，def tell_info(self):...obj.tell_info()
 
绑定到类的方法：就应该由类来调用，@classmethod def from_conf(cls):... class.from_conf()
 
非绑定方法：不与类或对象绑定，谁都可以调用，@classmethod def create_id():...
                obj.create_if()/class.create_id()

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

class A(object):
    pass
 
a = A()
 
a["key"] = "val"
a = a["key"]
del a["key"]

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

经典类：py2 没有继承object的类，以及它的子类都称之为经典类  --> 深度优先
 
新式类：py3 继承object的类，以及它的子类都称之为新式类       -->广度优先

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','存储过程的名字')

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

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

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

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

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()

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

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

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()

　报错内容：

Traceback (most recent call last):
  File "D:/py.py", line 27, in <module>
    d.eat()
TypeError: 'NoneType' object is not callable

改正如下：

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

　　因为有了property，用户就可以直接输入得到结果，对于使用者来说，感知不到其属性，这就是使用property的方便之处，此方法必须有一个返回值。return 或者print都可以。

为什么要用property？

　　一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则

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，多重继承的执行顺序，请解答以下输出结果是什么？并解释。

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

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领域建模的方式来设计类。

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

class Mymetaclass(type):
    def __new__(cls,name,bases,attrs):
        update_attrs={}
        for k,v in attrs.items():
            if not callable(v) and not k.startswith('__'):
                update_attrs[k.upper()]=v
            else:
                update_attrs[k]=v
        return type.__new__(cls,name,bases,update_attrs)
  
class Chinese(metaclass=Mymetaclass):
    country='China'
    tag='Legend of the Dragon' #龙的传人
    def walk(self):
        print('%s is walking' %self.name)
  
  
print(Chinese.__dict__)
'''
{'__module__': '__main__',
 'COUNTRY': 'China',
 'TAG': 'Legend of the Dragon',
 'walk': <function Chinese.walk at 0x0000000001E7B950>,
 '__dict__': <attribute '__dict__' of 'Chinese' objects>,                                        
 '__weakref__': <attribute '__weakref__' of 'Chinese' objects>,
 '__doc__': None}
'''

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

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

　结果：

# 结果：
# 1
# {'name': 'james', 'sex': 'male', 'age': 32}
# 2
# {'name': 'enbede', 'sex': 'male', 'age': 23}
# 2
# {'__module__': '__main__', '_count': 2, '__init__': <function Student.__init__ at 0x00000190B1B959D8>, 'learn': <property object at 0x00000190B19047C8>, 'tell_count': <staticmethod object at 0x00000190B1B9CAC8>, '__dict__': <attribute '__dict__' of 'Student' objects>, '__weakref__': <attribute '__weakref__' of 'Student' objects>, '__doc__': None}
# 总共实例化了：2
# james is learning

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

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

自定义用户信息数据结构，写入文件, 然后读取出内容, 利用json模块进行数据的序列化和反序列化
定义用户类，定义方法db，例如执行obj.db可以拿到用户数据结构
在该类中实现登录、退出方法, 登录成功将状态(status)修改为True, 退出将状态修改为False(退出要判断是否处于登录状态).密码输入错误三次将设置锁定时间(下次登录如果和当前时间比较大于10秒即不允许登录)

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")

28：编写一个学生类，产生一堆学生对象

　　要求：有一个计数器（属性），统计总共实例了多少个对象

class Studentclass:
    school = 'jiaotong university'
    count = 0
 
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex =sex
        Studentclass.count +=1
    def learn(self):
        print('%s is learning'%self.name)
stu1 = Studentclass('james',23,'male')
stu2 = Studentclass('poal',24,'male')
stu3 = Studentclass('harden',25,'male')
print(Studentclass.count)
print(stu1.__dict__)
print(stu2.__dict__)
print(stu3.__dict__)
print(stu1.count)
print(stu2.count)
print(stu3.count)

29：模仿王者荣耀定义两个英雄类

　　要求：

英雄需要有昵称、攻击力、生命值等属性；
实例化出两个英雄对象；
英雄之间可以互殴，被殴打的一方掉血，血量小于0则判定为死亡。

class Hero:
    def __init__(self,nickname,life_value,aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
 
class Garen(Hero):
   pass
 
class Riven(Hero):
    pass
g1=Garen('草丛论',100,20)
r1 = Riven('放逐之刃',80,50)
 
print(r1.life_value)
g1.attack(r1)
print(r1.life_value)

查看全文

相关阅读:
康托(逆)展开(2015.8.6)
高精度计算(2015.8.1)
笔记(2015.8.1)
筛法求素数(2015.7.30)
欧几里德算法(2015.7.28)
快速幂取模(2015.7.29)
同余
 图论相关算法
 笔记（2015-07-24）
ACM进阶计划

原文地址：https://www.cnblogs.com/anzhangjun/p/9335646.html