# 特性1.继承;2.多态;3.封装
# 1.继承的用处:通过继承就可以解决类与类之间的代码冗余关系
# 2.多态的用处:1.增加了程序的灵活性,以不变应万变,使用者都是同一种形式去调用(func(animal))2.增加了程序的可扩展性
# 3.封装的用处:1.在接口附加上对该数据操作的限制,以此完成对数据属性操作的严格控制 2.目的是隔离复杂度

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

# 类的属性有数据属性和函数属性,类的数据属性是所有对象共享的,类的函数属性是绑定给对象用的
# 对象的属性:对象是类的实例化

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

# 1.面向过程:复杂问题流程化进而简单化,但是代码扩展性查,不易维护
# 面向过程的应用场景:不需要再对代码做任何扩展了,检测脚本
# 2.面向对象:可扩展性强,面向对象只能解决扩展性,但是软件开发里可扩展性只是一部分,掌握面向对象是开发的一部分
# 面向对象的应用场景:用户的需求经常发生变化,互联网应用,游戏

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

类和对象的属性都是用字典的形式保存的

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

# 绑定到对象的定义:绑定对象的方法,类去访问自己的函数属性的时候就是一个普通的函数,没有自动调用的方式
# 绑定到对象的调用:绑定给谁,就应该谁来调用就会把调用者当做第一个参数自动传入
# 特性:绑定给对象就是对象调用,第一个参数是对象名,对象自动传参数,所有的类中的函数属性是默认绑定给对象的
"""
class Foo:
def bound(self):
print('from Foo')
f = Foo()
f.bound()
"""
# -------------------------
# 绑定到类的定义:在类的内部定义的,被装饰器classmethod修饰的方法
# 绑定到类的调用:由类来调用(对象也可以调用,不做限制,第一个参数会传类名)
# 特性:绑定给类就是类使用,但是对象也可以使用,第一个参数是类名
"""
class Foo:
@classmethod
def bound(cls):
print('%s被绑定到类的函数'%cls)
f = Foo()
# f.bound()
# Foo.bound()
"""
# -------------------------
# 非绑定方法的定义:不与类或者对象绑定,没有自动传值,谁都可以用,就相当于普通函数,一点都没有绑定关系
# 非绑定方法的调用:在类的内部定义的,被装饰器staticmethod修饰的方法
# 特性:解除绑定以后就是一个普通的函数工具,不自动传参,有几个参数就在调用的时候写几个参数
"""
class Foo:
def __init__(self, name):
self.name = name def tell(self):
print('名字是%s' %self.name) @staticmethod
def func1(x,y):#self? 不存在的!
return x+y f = Foo('panda')
print(Foo.func1(1,2))
print(f.func1(1,3))
"""

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

class A:
def __getitem__(self, item):
return self.__dict__.get(item)
def __setitem__(self, key, value):
self.__dict__[key] = value
def __delitem__(self, key):
del self.__dict__[key]
# Item系列
a = A()
# 设置数据,触发__setitem__内置方法,实现设置属性
a["key"] = "val"
print(a.__dict__)
# 获取数据,触发__getitem__内置方法,实现获取函数返回值
print(a["key"])
# 删除数据,触发__delitem__内置方法,实现删除key和value
del a["key"]
print(a.__dict__)
# 【小结】
# 1.__setattr__:对属性进行赋值或者修改的时候被调用
# 2.__getattr__:只有在调用属性时且属性不存在的情况下,触发這个函数的执行
# 3.__delattr__:当删除一个对象的属性值时,会触发delattr的执行

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

# python中的经典类:只出现在python2中,经典类的特征:没有继承object的类以及它的子类都称为经典类
# python中的新式类:出现在python2和python3中,新式类特征:继承object的类以及它的子类都称为新式类,python3默认继承object
# 经典类的继承顺序是深度优先(一条路线到底直到object),新式类的继承顺序是广度优先(同级到底,到object前停止)

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

8.如下示例, 请用面向对象的形式优化以下代码
'''
def exc1(host,port,db,charset,sql):
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 Mysql:
def __init__(self):
self.host = '127.0.0.1'
self.port = 3306
self.db = 'db1'
self.charset = 'utf-8' def connect(self):
return '地址%s 端口号%s 数据库名称%s 字符编码%s' % (self.host, self.port, self.db, self.charset) def execute(self,sql):
return 'SQL语句%s已经执行' % sql def call_proc(self,sql):
return '已保存%s文件'%sql sq = Mysql()
print(sq.connect())
print(sq.execute('select * from '))
print(sq.call_proc('test.txt'))
9.示例1, 现有如下代码, 会输出什么
class People(object):
__name = "luffy"
__age = 18
p1 = People()
print(p1.__name, p1.__age)
# 会报错,在类的执行阶段就会加载代码了,然后看到__name这种代码就会执行封装,变形以后隐藏,实例化的对象不使用特殊方法(a._A__N)是不能执行的
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__
# 原因分析:定义类后,类会先创建一个空对象(用__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()
# 补充代码
A.class_foo('id')
a.static_foo('panda')
# staticmethod(静态方法)就是将类中的函数变成一个普通函数,做成了函数工具,但是不会自动传参,需要多少参数就传多少参数
# classmethod(类方法)就是指定给类用的方法,对象也是可以用的,第一个参数就是传类名
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
# 原因解释:property是将类中的函数属性伪装成数据属性(不能传递参数),调用的时候直接就可以使用函数的方式就像,不需要加括号
class Parent(object):
x = 1 class Child1(Parent):
pass class Child2(Parent):
pass print(Parent.x, Child1.x, Child2.x)
# 输出结果 1 1 1 python3的继承遵循广度优先的规则,Child1会先在自己这里找x,没找到,去Parent里找到了,就拿来了,同理Child2
Child1.x = 2
print(Parent.x, Child1.x, Child2.x)
# 输出结果1 2 1 同样遵循广度优先的规则,Parent找到自己的x=1,Child1找到了刚定义的2,Child2没找到,就去Parent里找,找到了1
Parent.x = 3
print(Parent.x, Child1.x, Child2.x)
# 输出结果 3 2 3 广度优先,Parent里原来的x=1变成了x=3,Child1里x=2,Child2里没找到x,去Parent里找到x变化后的x=3

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

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()
f = F()
# g = G()输出结果:G>>D>>A>>B,广度优先(最后继承object的最后在找)
# f = F()输出结果:F>>C>>B>>D>>A 广度优先
15.请编写一段符合多态特性的代码.
import abc
class People(metaclass=abc.ABCMeta):
def __init__(self,name):
self.name = name
@abc.abstractmethod
def walk(self):
pass class Man(People):
def walk(self):
print('%s is walking' % self.name) class Women(People):
def walk(self):
print('%s is running' % self.name) pa = Man('panda')
pa.walk()
pa1 = Women('girl')
pa1.walk()

16.很多同学都是学会了面向对象的语法,却依然写不出面向对象的程序,原因是什么呢?原因就是因为你还没掌握一门面向对象设计利器,即领域建模,请解释下什么是领域建模,以及如何通过其设计面向对象的程序?

# 领域建模的三字经方法:找名词、加属性、连关系>>http://www.cnblogs.com/alex3714/articles/5188179.html >>给你个眼神,自己体会

17.请写一个小游戏,人狗大站,2个角色,人和狗,游戏开始后,生成2个人,3条狗,互相混战,人被狗咬了会掉血,狗被人打了也掉血,狗和人的攻击力,具备的功能都不一样。

# 注意,请按题14领域建模的方式来设计类。
# 1.找名词 人 狗
# 2.加属性 人:数据属性:name,health,attack函数属性:hit
# 狗:数据属性:name,health,attack函数属性:bit
# 抽象共性:人和狗属于动物:数据属性:name,health,attack
# 3.加关系
class Animal:
def __init__(self,name ,health,attack):
self.name = name
self.health = health
self.attack = attack class People(Animal):
def hit(self,enemy):
enemy.health -= self.attack class Dog(Animal):
def bit(self,enemy):
enemy.health -= self.attack P1 = People('panda',100,10)
P2 = People('zombie',120,10)
D1 = Dog('small_black',50,5)
D2 = Dog('big_yellow',60,6)
D3 = Dog('big_white',40,8) P1.hit(D1)
print(D1.health)
18.编写程序, 在元类中控制把自定义类的数据属性都变成大写.
class MyDef(type):
def __new__(cls, class_name, class_attr, class_dic):
upper_data = {}
for k,v in class_dic.items():
if not callable(v) and not k.startswith('__'):
upper_data[k.upper()] = v
else:
upper_data[k] = v
return type.__new__(cls, class_name, class_attr, upper_data) class People(metaclass=MyDef):
time = 'now'
work = 'weekends' print(People.__dict__)
20.编写程序, 编写一个学生类, 要求有一个计数器的属性, 统计总共实例化了多少个学生.
class Student:
count = 0
def __init__(self):
Student.count += 1
@classmethod
def counts(cls):
return cls.count
s1 = Student()
print(Student.counts())
s2 = Student()
print(Student.counts())
21. 编写程序, A 继承了 B, 俩个类都实现了 handle 方法, 在 A 中的 handle 方法中调用 B 的 handle 方法
class B:
def handle(self):
print('form B') class A(B):
def handle(self):
super().handle() a = A()
a.handle()
												

路飞学城Python-Day19(practise)的更多相关文章

  1. 路飞学城—Python爬虫实战密训班 第三章

    路飞学城—Python爬虫实战密训班 第三章 一.scrapy-redis插件实现简单分布式爬虫 scrapy-redis插件用于将scrapy和redis结合实现简单分布式爬虫: - 定义调度器 - ...

  2. 路飞学城—Python爬虫实战密训班 第二章

    路飞学城—Python爬虫实战密训班 第二章 一.Selenium基础 Selenium是一个第三方模块,可以完全模拟用户在浏览器上操作(相当于在浏览器上点点点). 1.安装 - pip instal ...

  3. 路飞学城Python爬虫课第一章笔记

    前言 原创文章,转载引用务必注明链接.水平有限,如有疏漏,欢迎指正. 之前看阮一峰的博客文章,介绍到路飞学城爬虫课程限免,看了眼内容还不错,就兴冲冲报了名,99块钱满足以下条件会返还并送书送视频. 缴 ...

  4. 路飞学城-Python开发集训-第3章

    学习心得: 通过这一章的作业,使我对正则表达式的使用直接提升了一个level,虽然作业完成的不怎么样,重复代码有点多,但是收获还是非常大的,有点找到写代码的感觉了,遗憾的是,这次作业交过,这次集训就结 ...

  5. 路飞学城-Python开发集训-第1章

    学习体会: 在参加这次集训之前我自己学过一段时间的Python,看过老男孩的免费视频,自我感觉还行,老师写的代码基本上都能看懂,但是实际呢?....今天是集训第一次交作业的时间,突然发现看似简单升级需 ...

  6. 路飞学城-Python开发集训-第4章

    学习心得: 学习笔记: 在python中一个py文件就是一个模块 模块好处: 1.提高可维护性 2.可重用 3.避免函数名和变量名冲突 模块分为三种: 1.内置标准模块(标准库),查看所有自带和第三方 ...

  7. 路飞学城-Python开发集训-第2章

    学习心得: 这章对编码的讲解超级赞,现在对于编码终于有一点认知了,但还没有大彻大悟,还需要更加细心的琢磨一下Alex博客和视频,以前真的是被编码折磨死了,因为编码的问题而浪费的时间很多很多,现在终于感 ...

  8. 路飞学城-Python开发-第二章

    ''' 数据结构: menu = { '北京':{ '海淀':{ '五道口':{ 'soho':{}, '网易':{}, 'google':{} }, '中关村':{ '爱奇艺':{}, '汽车之家' ...

  9. 路飞学城-Python开发-第三章

    # 数据结构: # goods = [ # {"name": "电脑", "price": 1999}, # {"name&quo ...

随机推荐

  1. 【原创】Vue.js 中 axios 跨域访问错误

    1.假如访问的接口地址为 http://www.test.com/apis/index.php  (php api 接口) 2.而开发地址为http://127.0.0.1:8080,当axios发起 ...

  2. [luogu3237 HNOI2014] 米特运输 (树形dp)

    传送门 Description 米特是D星球上一种非常神秘的物质,蕴含着巨大的能量.在以米特为主要能源的D星上,这种米特能源的运输和储存一直是一个大问题. D星上有N个城市,我们将其顺序编号为1到N, ...

  3. Django入门--自定义过滤器与标签

    ---恢复内容开始--- 为了让Django找到自定义的模板过滤器和模板标签,需要进行文件路径配置,配置方式分为APP目录下配置和项目路径下配置两种方式: 1.在APP目录下配置:针对某个应用特定的自 ...

  4. Ajax发送XML请求案例

    Ajax发送XML请求需求: 根据输入的国家,输出这些国家下面的城市. 如果请求参数较多,而且请求参数的结构关系复杂,则可以考虑发送XML请求.XML请求的实质还是POST请求,只是在发送请求的客户端 ...

  5. 使用UE4公布安卓平台游戏

    使用了几天的UE4 ,总算是将游戏在安卓平台执行起来了.当中遇到非常多问题,而且终于依旧有一些问题没能解决. 整体感觉是UE4这款引擎眼下还不够成熟.问题较多. 没有unity使用起来方便. 可是既然 ...

  6. Chromium网页输入事件捕捉和手势检測过程分析

    连续的输入事件可能会产生一定的手势操作.比如滑动手势和捏合手势. 在Chromium中,网页的输入事件是在Browser进程中捕捉的.Browser进程捕获输入事件之后,会进行手势操作检測.检測出来的 ...

  7. ADT、C和Java

    <编程导论(Java)·5 链表.数组和栈> 数据抽象使得用户程序猿在编写客户程序时,摆脱该数据类型的实现细节而只关心该数据类型的接口.在计算机科学中.有一些重要的数据抽象--数据结构,应 ...

  8. 《深入理解Android 卷III》第六章 深入理解控件(ViewRoot)系统

    <深入理解Android 卷III>即将公布,作者是张大伟.此书填补了深入理解Android Framework卷中的一个主要空白,即Android Framework中和UI相关的部分. ...

  9. lvs 负载均衡环境搭建

    记录一下搭建lvs环境的步骤 当中master 10.0.0.11,backup 10.0.0.15.realserver1 10.0.0.119.realserver210.0.0.11 1.mkd ...

  10. android 虚拟按键是通过哪种机制上报的?

    1.在normal mode下,tp button也是和其他触摸事件一样,以坐标形式的input_event进行上报.在初始化时会通过tpd_button_setting()函数依据定义在tpd_cu ...