python学习笔记-(十)面向对象基础

面向对象相关知识简介

  • 类(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。类对象创建后,类命名空间中所有

的命名都是有效属性名。所以如果类定义是这样:


1

2

3

4

5

6

7

8

#定义一个类,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)

= user(‘dd‘)#---根据类user创建对象i

i.uname()#执行uname方法

2.1.1 零散知识点集锦:

  • 类变量和实例变量

类变量:

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

实例变量:

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


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

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


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

28

29

30

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 在内存中保存的方式,根据保存格式可以如此调用被封装的内容:对象.属性名


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

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间接调用被封装的内容


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

# 创建一个类,类名是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 继承

2.2.1 

2.2.3 多态

时间: 08-29

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

python学习笔记十——异常处理

1.try: command except 错误类型,记录错误信息变量: command finally: command try...finally的用处是无论是否发生异常都要确保资源释放代码的执行.一般来说,如果没有发生错误,执行过try语句块之后执行finally语句块,完成整个流程.如果try语句块发生了异常,抛出了这个异常,此时就马上进入finally语句块进行资源释放处理.如下从几个细节讨论finally的特性. 1).try中的return: 当在try语句块中含有return语句

Day3: Python学习笔记之计算机基础——网络片

Day3: Python学习笔记之计算机基础--网络片 什么是互联网协议以及为何要有互联网协议? ?互联网协议本质上是为了方便连接两台计算机而指定的一系列统一的标准. osi五层模型 计算机之间要实现数据传输必须要经过以下五层协议: ? 模型 ,协议 ,硬件 ? 应用层, http协议.用户自定义协议 ? 传输层, TCP/UPD协议 ,四层交换机.四层路由器 ? 网络层, IP协议, 三层交换机.路由器 ? 数据链路层, 以太网.电信号分组, 网桥.以太网交换机.网卡 ? 物理层, 传递电信号

python学习笔记12-python面向对象

python学习笔记12-python面向对象 python一切皆对象 一.基本概念 1.面向对象和面向过程 面向对象编程:C++,Java,Python 面向过程编程:函数式编程,C程序等 2.类和对象 类:是对事物的抽象,比如:人类,球类 对象:是类的一个实例,比如:足球,篮球,对象就是对类的实例化 属性:五官,眼,鼻子,理解为一个变量,静态属性 方法:对人来说,吃穿住行,理解为一个函数,动态方法 实例说明:球类可以对球的特征和行为进行抽象,然后可以实例化一个真实的球实体出来 3.为什么要使

Python学习笔记day1【基础介绍】

Alex博客:http://www.cnblogs.com/alex3714/articles/5465198.html 一.本节主要内容 Python介绍 发展史 Python 2 or 3? 安装 Hello World程序 变量 用户输入 模块初识 .pyc文件 数据类型初识 数据运算 表达式if ...else语句 表达式for 循环 break and continue 表达式while 循环 作业需求 二.具体内容 1.python介绍 python的创始人为吉多·范罗苏姆(Guid

python学习笔记十五 django基础

Python的WEB框架有Django.Tornado.Flask 等多种,Django相较与其他WEB框架其优势为:大而全,框架本身集成了ORM.模型绑定.模板引擎.缓存.Session等诸多功能. 1.创建django程序 通过命令行 django-admin startproject mysite 创建project 一个工程可以包含多个app,app共用一个project的配置文件 cd mysite python manage.py startapp app01 创建app01 pyt

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

1.CSS 简介 CSS 指层叠样式表 (Cascading Style Sheets) 样式定义如何显示 HTML 元素 样式通常存储在样式表中 把样式添加到 HTML 4.0 中,是为了解决内容与表现分离的问题 外部样式表可以极大提高工作效率 外部样式表通常存储在 CSS 文件中 多个样式定义可层叠为一 css存在方式: 元素内联 页面嵌入 外部引入 语法:style = 'key1:value1;key2:value2;' 1.元素内联(在标签中使用css) <!--在标签使用--> &

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

HTML 超级文本标记语言是标准通用标记语言下的一个应用,也是一种规范,一种标准,它通过标记符号来标记要显示的网页中的各个部分.网页文件本身 是一种文本文件,通过在文本文件中添加标记符, 可以告诉浏览器如何显示其中的内容(如:文字如何处理,画面如何安排,图片如何显示等).浏览器按顺序阅读 网页文件,然后根据标记符解释和显示其标记的内容,对书写出错的标记将不指出其错误, 且不停止其解释执行过程,编制者只能通过显示效果来分析出错原因和出 错部位.但需要注意的是,对于不同的浏览器,对同一标记符可能会有

Python学习笔记八 面向对象高级编程(一)

参考教程:廖雪峰官网https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000 一.使用__slots__ 正常情况下,当定义了一个类之后,我们可以给这个类的实例绑定任何属性,这就是动态语言的优势: class Student(object): def __init__(self,name,age): self.name=name self.age=age bob=Student('Bob

Python学习笔记八 面向对象高级编程(二)元类

参考教程:廖雪峰官网https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000 在廖老师的学习网站里"使用元类"这部分还是把我给看晕了...网上搜到一篇感觉讲的相对易懂一些,贴出链接:两句话掌握 Python 最难知识点--元类--以此文作为这篇笔记的源本. "道生一,一生二,二生三,三生万物" 1.在Python世界中,"type"即为道

python学习笔记十六 django深入学习一

django 请求流程图 django 路由系统 在django中我们可以通过定义urls,让不同的url路由到不同的处理函数 from . import views urlpatterns = [ url(r'^articles/2003/$', views.special_case_2003), #精确匹配 url(r'^articles/([0-9]{4})/$', views.year_archive), #动态路由 url(r'^articles/([0-9]{4})/([0-9]{2