面向对象相关知识简介

  • 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
  • 类变量:类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
  • 数据成员:类变量或者实例变量用于处理类及其实例对象的相关的数据。
  • 方法重写:如果从父类继承的方法不能满足子类的需求,可以对其进行改写,这个过程叫方法的覆盖(override),也称为方法的重写。
  • 实例变量:定义在方法中的变量,只作用于当前实例的类。
  • 继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。
  • 实例化:创建一个类的实例,类的具体对象。
  • 方法:类中定义的函数。
  • 对象:通过类定义的数据结构实例。对象包括两个数据成员(类变量和实例变量)和方法。

编程范式

  编程是程序员用特定的语法+数据结构+算法组成的代码来告诉计算机如何执行任务的过程,一个程序是程序员为了得到一个任务结果而编写的一组指令的集合,正所谓条条大路通罗马,实现一个任务的方式有很多种不同的方式,对这些不同的编程方式的特点进行归纳总结得出来的编程方式类别,即为编程范式。不同的编程范式本质上代表对各种类型的任务采取的不同的解决问题的思路,大多数语言只支持一种编程范式,当然也有些语言可以同时支持多种编程范式。

  两种最重要的编程范式分别是:面向过程编程和面向对象编程。

1.面向过程编程(Procedural Programming)

  就是程序从上到下一步步执行,一步步从上到下,从头到尾的解决问题。基本设计思路就是程序一开始是要着手解决一个大的问题,然后把一个大问题分解成很多个小问题或子过程,这些子过程再执行的过程再继续分解直到小问题足够简单到可以在一个小步骤范围内解决。

  这样做的问题也是显而易见的,就是如果你要对程序进行修改,对你修改的那部分有依赖的各个部分你都也要跟着修改,举个例子,如果程序开头你设置了一个变量值为1,但如果其它子过程依赖这个值为1的变量才能正常运行,那如果你改了这个变量,那这个子过程你也要修改,假如又有一个其它子程序依赖这个子过程,那就会发生一连串的影响,随着程序越来越大,这种编程方式的维护难度会越来越高。   

  所以我们一般认为,如果你只是写一些简单的脚本,去做一些一次性任务,用面向过程的方式是极好的;但如果你要处理的任务是复杂的,且需要不断迭代和维护的,那还是用面向对象最方便了。

2. 面向对象编程(Object Oriented Programming)

  面向对象编程是一种编程方式,此编程方式的落地需要使用"类"和"对象"来实现,所以,面向对象编程其实就是对"类"和"对象"的使用。

  使用面向对象编程的原因一方面是因为它可以使程序的维护和扩展变得更简单,并且可以大大提高程序开发效率;另外,基于面向对象的程序可以使它人更加容易理解你的代码逻辑,从而使团队开发变得更从容。

2.1 类和对象

  类就是一个模板,模板里可以包含多个函数,函数里实现一些功能;---函数在类中被称为方法

  对象则是根据模板创建的实例,通过实例对象可以执行类中的函数;

  类对象支持两种操作:属性引用和实例化。属性引用使用和Python中所有的属性引用一样的标准语法:obj.name。类对象创建后,类命名空间中所有的命名都是有效属性名。所以如果类定义是这样:

#定义一个类,class是定义类的语法;user是类名;(object)是新式类的写法,必须这么写;(额。。什么是新式类?暂时忘记他吧!)
class user(object):
def __init__(self,name):#初始化函数,(self,name)里是要初始化的属性,其中self为特殊参数,必填项;name为实际参数
self.name = name#实例变量,作用域就是实例本身
def uname(self):#---类中创建了一个方法uname
print("%s is the best!" % self.name)
i = user('dd')#---根据类user创建对象i
i.uname()#执行uname方法

2.1.1 零散知识点集锦:

  • 类变量和实例变量

类变量:

是可在类的所有实例之间共享的值(也就是说,它们不是单独分配给每个实例的)。

实例变量:

实例化之后,每个实例单独拥有的变量。

class Test(object):
num_of_instance = 0
def __init__(self, name):
self.name = name
Test.num_of_instance += 1 if __name__ == '__main__':
print Test.num_of_instance
t1 = Test('cc')
print Test.num_of_instance
t2 = Test('lucy')
print t1.name , t1.num_of_instance
print t2.name , t2.num_of_instance -------------------------------打印输出-------------------------------
0
1
cc 2
lucy 2
  • 析构函数

上面我们已经知道构造函数__init__,具有初始化的作用,也就是当该类被实例化的时候就会执行该函数,那么我们就可以把要先初始化的属性放到这个函数里面。

那么与之对应的就是析构函数__del__,用于释放对象占用的资源的函数,做收尾工作,例如关闭数据库、打开临时文件等;

__del__()也是可选的,如果不提供,则Python 会在后台提供默认析构函数

如果要显式的调用析构函数,可以使用del关键字,方式如下:

del对象名

  • 私有属性和方法

1)类的私有属性

__private_attrs:两个下划线开头,声明该属性为私有,不能在类地外部被使用或直接访问。在类内部的方法中使用时self.__private_attrs

2)类的私有方法

__private_method:两个下划线开头,声明该方法为私有方法,不能在类地外部调用。在类的内部调用 slef.__private_methods

class JustCounter:
__secretCount = 0 # 私有变量
publicCount = 0 # 公开变量 def count(self):
self.__secretCount += 1
self.publicCount += 1
print(self.__secretCount)
def __count(self):#私有方法
self.__secretCount -=1
self.publicCount -= 1
print(self.__secretCount)
counter = JustCounter()
counter.count()
print(counter.publicCount)
print(counter.__secretCount) # 报错,实例不能访问私有变量 -----------打印输出----------------
AttributeError: 'JustCounter' object has no attribute '__secretCount' #---------------------------我是华丽的分割线------------------------- #我们注释掉print(counter.__secretCount),加上下面这句再试试 counter.__count()#访问私有方法 -----------打印输出----------------
1
1
Traceback (most recent call last):
File "E:/python/new/new.py", line 20, in <module>
counter.__count()#访问私有方法
AttributeError: 'JustCounter' object has no attribute '__count'

2.2 面向对象的三大特性

2.2.1 封装

封装,顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。

所以,在使用面向对象的封装特性时,需要:

  • 将内容封装到某处
  • 从某处调用被封装的内容

第一步:将内容封装到某处

self是一个形式参数,当执行obj1=Foo('cc',18)时,self等于obj1;当执行obj2=Foo('coco',22)时,self等于obj2;

所以,内容其实被封装到了对象obj1和obj2中,每个对象中都有name和age属性,在内存里类似于下图来保存。

第二步:从某处调用被封装的内容

调用被封装的内容时,有两种情况:

  • 通过对象直接调用
  • 通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式,根据保存格式可以如此调用被封装的内容:对象.属性名

class Foo:
def __init__(self, name, age):
self.name = name
self.age = age
obj1 = Foo('cc', 18)
print(obj1.name) # 直接调用obj1对象的name属性
print(obj1.age) # 直接调用obj1对象的age属性
obj2 = Foo('coco', 22)
print(obj2.name) # 直接调用obj2对象的name属性
print(obj2.age) # 直接调用obj2对象的age属性
----------------------------打印输出-------------------------------------
cc
18
coco
22

2、通过self间接调用被封装的内容

执行类中的方法时,需要通过self间接调用被封装的内容

# 创建一个类,类名是Class_basis
class Class_basis:
# 在类里面创建了一个方法ret
def ret(self,):
# 输出self的内存地址
print("方法ret的self内存地址", id(self)) # 创建一个对象obj,类名后面加括号
obj = Class_basis() # 输出对象obj的内存地址
print("obj对象内存地址", id(obj)) # 通过对象调用类中的ret方法
obj.ret()
-------------------打印输出---------------------------
obj对象内存地址 2513776
方法ret的self内存地址 2513776

通过上面的测试可以很清楚的看到obj对象和类的方法中self内存地址是一样的,那么方法中的self就等于obj;

----------self是形式参数,由python自行传递

综上所述,对于面向对象的封装来说,其实就是使用构造方法将内容封装到对象中,然后通过对象直接或者self间接获取被封装的内容。综上所述,对于面向对象的封装来说,其实就是使用构造方法将内容封装到对象中,然后通过对象直接或者self间接获取被封装的内容。

2.2.2 继承

面向对象的编程带来的主要好处之一是代码的重用,实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

通过继承创建的新类称为“子类”或“派生类”。

被继承的类称为“基类”、“父类”或“超类”。

继承的过程,就是从一般到特殊的过程。

要实现继承,可以通过“继承”(Inheritance)和“组合”(Composition)来实现。

  • 什么时候用:

上面我们说过,用继承可以代码重用;那么大家可以考虑下:我定义几个类,而这些类有一些公共的属性和方法,那么我们可以把相同的属性和方法提取出来作为基类的成员,特殊的方法和属性在本类定义;这样只需要继承基类这个动作,就可以访问到基类的属性和方法了,它提高了代码的可扩展性。

  • 缺点:

凡事必有两面性,了解了继承的优点,我们也需要对他的缺点有所了解:可能特殊的本类又有其他特殊的地方,又会定义一个类,其下也可能再定义类,这样就会造成继承的那条线越来越长,使用继承的话,任何一点小的变化也需要重新定义一个类,很容易引起类的爆炸式增长,产生一大堆有着细微不同的子类. 所以有个“多用组合少用继承”的原则。

  • 特点:

1)在继承中基类的构造(__init__()方法)不会被自动调用,它需要在其派生类的构造中亲自专门调用;

2)在调用基类的方法时,需要加上基类的类名前缀,且需要带上self参数变量。区别于在类中调用普通函数时并不需要带上self参数;

3)Python总是首先查找对应类型的方法,如果它不能在派生类中找到对应的方法,它才开始到基类中逐个查找。(先在本类中查找调用的方法,找不到才去基类中找)。

  • 经典类与新式类

经典类和新式类,从字面上可以看出一个老一个新,新的必然包含了跟多的功能,也是之后推荐的写法,从写法上区分的话,如果 当前类或者父类继承了object类,那么该类便是新式类,否则便是经典类。

class u1:
pass #经典类
class u2(u1):
pass #经典类 class t1(object):
pass #新式类
class t2(t1):
pass #新式类
  • 怎么用:

1)普通继承

class SchoolMember(object):
members = 0 # 初始学校人数为0
def __init__(self, name, age):
self.name = name
self.age = age
def tell(self):
print("SchoolMember的名字是:%s!"%self.name)
class Teacher(SchoolMember):#继承了父类
def __init__(self,name,age,course,salary):
SchoolMember.__init__(self,name,age)#继承了父类的属性
self.course = course
self.salary = salary
print("Teacher的名字是:%s!" % self.name) def teaching(self):
'''讲课方法'''
print("Teacher [%s] is teaching [%s] for class [%s]" % (self.name, self.course, 's12'))
class Student(SchoolMember):
def __init__(self, name, age,classes):
SchoolMember.__init__(self,name, age) # 继承了父类的属性
self.classes = classes
def tell(self):#覆盖了父类的tell方法
SchoolMember.tell(self)
print("Student的名字是:%s!" % self.name)
teacher = Teacher("cc",18,"python",10000)
teacher.tell()
student = Student("tt",20,307)
student.tell() ----------------------打印输出-------------------------
Teacher的名字是:cc!
SchoolMember的名字是:cc!
SchoolMember的名字是:tt!
Student的名字是:tt!

2)super继承

class SchoolMember(object):
members = 0 # 初始学校人数为0
def __init__(self, name, age):
self.name = name
self.age = age
def tell(self):
print("SchoolMember的名字是:%s!"%self.name)
class Teacher(SchoolMember):#继承了父类
def __init__(self,name,age,course,salary):
super(Teacher,self).__init__(name, age)#继承了父类的属性
self.course = course
self.salary = salary
print("Teacher的名字是:%s!" % self.name) def teaching(self):
'''讲课方法'''
print("Teacher [%s] is teaching [%s] for class [%s]" % (self.name, self.course, 's12'))
class Student(SchoolMember):
def __init__(self, name, age,classes):
super(Student, self).__init__(name, age) # 继承了父类的属性
self.classes = classes
def tell(self):#覆盖了父类的tell方法
print("Student的名字是:%s!" % self.name)
teacher = Teacher("cc",18,"python",10000)
teacher.tell()
student = Student("tt",20,307)
student.tell() ------------------------打印输出------------------------
Teacher的名字是:cc!
SchoolMember的名字是:cc!
Student的名字是:tt!

3)多继承

多继承的意思就是继承多个类;

那么问题来了:Python的类如果继承了多个类,他寻找方法的查询策略是什么呢?

Python2中经典类是按深度优先来继承的;新式类是按广度优先来继承的;

Python3中经典类和新式类都是统一按广度优先来继承的;

class D(object):
# def bar(self):
# print('D.bar')
pass
class C(D):
# def bar(self):
# print('C.bar')
pass
class B(D):
# def bar(self):
# print('B.bar')
pass
class A(B, C):
# def bar(self):
# print('A.bar')
pass a = A()
a.bar()
# 执行bar方法时
# 首先去A类中查找,如果A类中没有,则继续去B类中找,如果B类中么有,则继续去C类中找,如果C类中么有,则继续去D类中找,如果还是未找到,则报错
# 所以,查找顺序:A --> B --> C --> D
# 在上述查找bar方法的过程中,一旦找到,则寻找过程立即中断,便不会再继续找了 #上面我们可以看到最终的结果是报错:AttributeError: 'A' object has no attribute 'bar';可依次调整查看结果是否与预期一致

总结:上面我们可以看出super与普通继承相比,公共类只被执行了一次,这一点在多重继承时体现的非常明显;

2.2.3 多态

多态是允许将父对象设置成为和一个或多个它的子对象相等的技术,比如Parent:=Child; 多态性使得能够利用同一类(基类)类型的指针来引用不同类的对象,以及根据所引用对象的不同,以不同的方式执行相同的操作.

python是一种动态语言,参数在传入之前是无法确定参数类型的,so python本身是不支持多态的,不过可以间接实现。

class Animal:
def __init__(self, name):
self.name = name
def talk(self):
raise NotImplementedError("Subclass must implement abstract method") class Cat(Animal):
def talk(self):
return 'Meow!' class Dog(Animal):
def talk(self):
return 'Woof! Woof!' animals = [Cat('Missy'),
Dog('Lassie')] for animal in animals:
print(animal.name + ': ' + animal.talk()) -----------------打印输出----------------------
Missy: Meow!
Lassie: Woof! Woof! 

python学习笔记-(十)面向对象基础的更多相关文章

  1. Python学习笔记(十二)—Python3中pip包管理工具的安装【转】

    本文转载自:https://blog.csdn.net/sinat_14849739/article/details/79101529 版权声明:本文为博主原创文章,未经博主允许不得转载. https ...

  2. python学习笔记六 面向对象相关下(基础篇)

    面向对象基本知识: 面向对象是一种编程方式,此编程方式的实现是基于对 类 和 对象 的使用 类 是一个模板,模板中包装了多个“函数”供使用(可以将多函数中公用的变量封装到对象中) 对象,根据模板创建的 ...

  3. python 学习笔记十五 django基础

    Python的WEB框架有Django.Tornado.Flask 等多种,Django相较与其他WEB框架其优势为:大而全,框架本身集成了ORM.模型绑定.模板引擎.缓存.Session等诸多功能. ...

  4. python 学习笔记十二 html基础(进阶篇)

    HTML 超级文本标记语言是标准通用标记语言下的一个应用,也是一种规范,一种标准,它通过标记符号来标记要显示的网页中的各个部分.网页文件本身 是一种文本文件,通过在文本文件中添加标记符, 可以告诉浏览 ...

  5. python 学习笔记十二 CSS基础(进阶篇)

    1.CSS 简介 CSS 指层叠样式表 (Cascading Style Sheets) 样式定义如何显示 HTML 元素 样式通常存储在样式表中 把样式添加到 HTML 4.0 中,是为了解决内容与 ...

  6. Python学习笔记一(基础信息)

    目录 输入输出 数据类型和变量 整数 浮点数 字符串 布尔值 空值 变量 常量 小结 欢迎关注我的博客我在马路边 说明:此笔记不是从零开始,在学习的过程中感觉需要记录一些比较重要和需要重复浏览的信息, ...

  7. python 学习笔记7 面向对象编程

    一.概述 面向过程:根据业务逻辑从上到下写垒代码 函数式:将某功能代码封装到函数中,日后便无需重复编写,仅调用函数即可 面向对象:对函数进行分类和封装,让开发"更快更好更强..." ...

  8. python 学习笔记十九 django深入学习四 cookie,session

    缓存 一个动态网站的基本权衡点就是,它是动态的. 每次用户请求一个页面,Web服务器将进行所有涵盖数据库查询到模版渲染到业务逻辑的请求,用来创建浏览者需要的页面.当程序访问量大时,耗时必然会更加明显, ...

  9. python 学习笔记十八 django深入学习三 分页,自定义标签,权限机制

    django  Pagination(分页) django 自带的分页功能非常强大,我们来看一个简单的练习示例: #导入Paginator>>> from django.core.p ...

  10. python 学习笔记十六 django深入学习一 路由系统,模板,admin,数据库操作

    django 请求流程图 django 路由系统 在django中我们可以通过定义urls,让不同的url路由到不同的处理函数 from . import views urlpatterns = [ ...

随机推荐

  1. hihocoder1241 Best Route in a Grid

    题目链接:hihocoder 1241 题意: n*n的格阵,每个方格内有一个数字.蚂蚁从左上角走到右下角,数字是零的方格不能走,只能向右向下走.蚂蚁走的路径上全部方格的的乘积为s,要使s低位0的个数 ...

  2. webpack入坑之旅(一)不是开始的开始

    最近学习框架,选择了vue,然后接触到了vue中的单文件组件,官方推荐使用 Webpack + vue-loader构建这些单文件 Vue 组件,于是就开始了webpack的入坑之旅.因为原来没有用过 ...

  3. RabbitMQ 主题(Topic)

    我们进步改良了我们的日志系统.我们使用direct类型转发器,使得接收者有能力进行选择性的接收日志,,而非fanout那样,只能够无脑的转发. 虽然使用direct类型改良了我们的系统,但是仍然存在一 ...

  4. 你需要知道的MySQL开源存储引擎TokuDB

    在四月份的Percona Live MySQL会议上, TokuDB庆祝自己成为开源存储引擎整一周年.我现在仍能记得一年前它刚创建时的官方声明与对它的期望.当时的情况非常有意思,因为它拥有帮助MySQ ...

  5. iOS开发小技巧--计算label的Size的方法总结

    计算label的Size方法 sizeWithAttributes:方法 适用于不换行的情况,宽度不受限制的情况 /// 根据指定文本和字体计算尺寸 - (CGSize)sizeWithText:(N ...

  6. iOS开发小技巧--利用MJExtension解决数据结构复杂的模型转换

    一.开发中难免会遇到,系统返回的数据中字典套集合,集合里面又套一层字典,然后字典里面还有字典或者集合等等的复杂结构的数据...MJExtension轻松搞定这类问题 1.解决方法一: 例:百思项目中帖 ...

  7. Mysql Optimization Overview

    The information below i get from http://dev.mysql.com/doc/refman/8.0/en/optimize-overview.html Optim ...

  8. HTML5文件系统API和资料整理

    来着火狐开发网络的官方文档:点我打开 : W3C的官方文档: 点我打开 : 园友的博客:  点我打开: 浏览器兼容性, 好了就chrome支持, 我刚刚更新的火狐37也不支持, nice, 太nice ...

  9. c#读取excel

    Provider根据实际EXCEL的版本来设置,推荐使用ACE接口来读取.需要Access database Engine. 注意修改注册表以下两项的值为0.否则导入EXCEL当单元格内字符长度超过2 ...

  10. 图像卷积、相关以及在MATLAB中的操作

    图像卷积.相关以及在MATLAB中的操作 2016年7月11日 20:34:35, By ChrisZZ 区分卷积和相关 图像处理中常常需要用一个滤波器做空间滤波操作.空间滤波操作有时候也被叫做卷积滤 ...