python 要掌握面向对象,你得会做这些题
1,面向对象三大特性,各有什么用处,说说你的理解。
1
2
3
4
5
|
继承:解决代码重用问题 多态:多态性,可以在不考虑对象类型的情况下而直接使用对象 封装:明确的区分内外,控制外部对隐藏属性的操作行为,隔离复杂度 |
2,类的属性和对象的属性有什么区别?
1
2
3
|
类的属性:数据属性和函数属性,数据属性是所有对象共有的,函数属性是绑定对象使用的 对象的属性:对象是类的实例化 |
3,面向过程编程与面向对象编程的区别与应用场景?
1
2
3
4
5
|
面向过程:复杂的问题流程化,简单化 应用场景:不再需要扩展了,监测脚本,自动部署脚本,软件解压安装 面向对象:特征与技能的结合体 一切皆对象 应用场景:用户需求经常变化,互联网应用,游戏,企业内部应用 |
4,类和对象在内存中是如何保存的。
1
|
类和对象的属性:以字典的形式保存的 |
5,什么是绑定到对象的方法、绑定到类的方法、解除绑定的函数、如何定义,如何调用,给谁用?有什么特性
1
2
3
4
5
6
|
绑定到对象的方法:就应该由对象来调用, 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,使用实例进行 获取、设置、删除 数据, 分别会触发类的什么私有方法
1
2
3
4
5
6
7
8
|
class A( object ): pass a = A() a[ "key" ] = "val" a = a[ "key" ] del a[ "key" ] |
7,python中经典类和新式类的区别
1
2
3
|
经典类:py2 没有继承 object 的类,以及它的子类都称之为经典类 - - > 深度优先 新式类:py3 继承 object 的类,以及它的子类都称之为新式类 - - >广度优先 |
8,如下示例, 请用面向对象的形式优化以下代码
1
2
3
4
5
6
7
8
9
10
11
12
|
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, 现有如下代码, 会输出什么:
1
2
3
4
5
6
|
class People( object ): __name = "luffy" __age = 18 p1 = People() print (p1.__name, p1.__age) |
10,示例2, 现有如下代码, 会输出什么:
1
2
3
4
5
6
7
8
9
10
|
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(类方法), 并分别补充代码执行下列方法。
静态方法:非绑定方法,类和对象都可以调用
类方法:绑定给类的方法啊,类调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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可以将函数属性转化为数据属性
1
2
3
4
5
6
7
8
9
10
11
|
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() |
报错内容:
1
2
3
4
|
Traceback (most recent call last): File "D:/py.py" , line 27 , in <module> d.eat() TypeError: 'NoneType' object is not callable |
改正如下:
1
2
3
4
5
6
7
8
9
10
11
|
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,下面这段代码的输出结果将是什么?请解释。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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
3
4
5
6
7
8
9
10
11
|
领域模型,顾名思义,就是需求所涉及的领域的一个建模,更通俗的讲法是业务模型。 定义: 需求到面向对象的桥梁 作用: 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,编写程序, 在元类中控制把自定义类的数据属性都变成大写.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
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
2
3
4
5
6
7
8
9
|
# 结果: # 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 序列化保存到文件里,并在下一次重启程序时能读取到创建的老师, 例如程序目录结构如下.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
. | - - 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题, 它们雷同的功能, 是否可以通过继承的方式进行一些优化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
伪代码 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:编写一个学生类,产生一堆学生对象
要求:有一个计数器(属性),统计总共实例了多少个对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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则判定为死亡。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
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) |