Python第七章-面向对象

Posted 平仄平仄平平仄

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python第七章-面向对象相关的知识,希望对你有一定的参考价值。

面向对象编程基础

一、面向对象概念

1.1 什么是面向过程

​ 就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。

​ 生活中的的例子举例。

1.2 什么是面向对象

​ 面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。

  1. 面向对象是一种思维方法
  2. 面向对象是一种编程方法
  3. 面向对象并不只针对某一种编程语言

1.3 面向对象和面向过程的区别和联系

面向过程,做什么

面向过程过程侧重整个问题的解决步骤,着眼局部或者具体,核心:过程的实现

【面向过程】:
为了把大象装进冰箱,需要3个过程。

  1. 把冰箱门打开(得到打开门的冰箱)
  2. 把大象装进去(打开门后,得到里面装着大象的冰箱)
  3. 把冰箱门关上(打开门、装好大象后,获得关好门的冰箱)
    每个过程有一个阶段性的目标,依次完成这些过程,就能把大象装进冰箱。

面向对象,谁来做

面向对象侧重具体的功能,让某个对象具有这样的功能。更加侧重于整体。核心:对象

【面向对象】:
为了把大象装进冰箱,需要做三个动作(或者叫行为)。
每个动作有一个执行者,它就是对象。

  1. 冰箱,你给我把门打开
  2. 大象,你给我钻到冰箱里去
  3. 冰箱,你给我把门关上
    依次做这些动作,就能把大象装进冰箱。
各自的优缺点

面向过程的优点:
      流程化使得编程任务明确,在开发之前基本考虑了实现方式和最终结果;
      效率高,面向过程强调代码的短小精悍,善于结合数据结构来开发高效率的程序。。
      流程明确,具体步骤清楚,便于节点分析。

  缺点是:需要深入的思考,耗费精力,代码重用性低,扩展能力差,维护起来难度比较高,
          对复杂业务来说,面向过程的模块难度较高,耦合度也比较高。

面向对象的优点:结构清晰,程序便于模块化,结构化,抽象化,更加符合人类的思维方式;
    封装性,将事务高度抽象,从而便于流程中的行为分析,也便于操作和自省; 
    容易扩展,代码重用率高,可继承,可覆盖;
    实现简单,可有效地减少程序的维护工作量,软件开发效率高。

  缺点是:效率低,面向对象在面向过程的基础上高度抽象,从而和代码底层的直接交互非常少机会,
              从而不适合底层开发和游戏甚至多媒体开发;
              复杂性,对于事务开发而言,事务本身是面向过程的,过度的封装导致事务本身的复杂性提高。

编程语言对面向对象的实现主流的有两种方式:基于类的面向对象和基于原型的面向对象。

不管以什么方式实现,都具有面向对象的三大特征:

  • 封装

    也就是把客观事物封装成抽象的类或具体的对象,并且类或对象可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。

  • 继承

    可以让某个类型的对象获得另一个类型的对象的属性的方法

  • 多态

    不同实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。

1.4编程语言中面向对象的实现方式

1.4.1基于类的面向对象

典型的语言:Java、C#、 pthon 、c++等

对象(object)依靠 类(class)来产生

1.4.2基于原型的面向对象

典型的语言:JavaScript

对象(object)则是依靠 构造器(constructor)利用 原型(prototype)构造出来的

二、python中的类

python 是基于类的面向的对象语言, 所以学习 python 面向对象, 必须要先学习类

2.1类和实例的概念

通过前面的学习我们已经知道, 面向对象编程(Object Oriented Programming,简称OOP),是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了 数据和操作数据的函数(方法)

而面向对象的程序设计把计算机程序视为一组对象的集合,而每个对象都可以接收其他对象发过来的消息,并处理这些消息,计算机程序的执行就是一系列消息在各个对象之间传递。


2.1.1 类的理解

在 python 中所有类型的数据都可以看成对象, 包括我们我们以前学习的所有的内置类型int, float等.

像这些 int, float, list这些数据类型, 就是我们面向对象中的类

我们可以根据需要自定义很多类型出来, 这些自定义的类型也是我们面向对象中的类


2.1.2对象的理解

我们天天说对象, 到底该怎么去理解对象?

a = 3 变量 a 赋值为整数 3, 这里的 3 就是一个int类型的对象.
nums = [2, 4, 1] 这里的 [2, 4, 1] 就是list类型的列表对象.

可以这么说, 在 python 中任何类型的数据数据都是对象.(和其他语言 c++, java 等不太一样, 他们有一些不是对象的基本数据类型)

对象其实就是对数据和操作数据的方法进行的封装


2.1.3类与对象的关系

类与对象的关系, 就是我们每个人同人类的关系一样.

人类是对每个具体的人的共同的特点的抽象. 比如都有手脚, 耳朵, 还都可以吃饭, 娱乐, 男人还可以去大保健. 人类就是编程语言中的类型.

而每个人是人类的一个个的具体的实现. 每个人都是编程语言中的一个对象


类是对对象的抽象描述, 而对象是类的具体实现. 他们是抽象与具体的关系.


例如:
汽车制造图纸和一个个的汽车.

图纸就是类, 汽车就是对象


2.1.4先有对象还是先有类

看情况:

  1. 在做面向对象分析的时候, 一般是先有对象, 然后把对象的共性抽象出来, 然后就形成了类.
  2. 编写代码的时候, 一般是先完成类的编写, 然后在需要的时候创建对象就可以了.

2.2 定义类

我们需要关键字class来定义类

class 类名:
    # 类中定义的内容

比如我们定义一个表示学生的Student类:

class Student:
    pass

说明:

  1. class 后面紧跟类名. 类名的命名使用驼峰命名法.
  2. 类名的后面跟一个冒号
  3. 然后是带有正确缩进的类的主体.(上面的例子中使用 pass, 表示空的类主体)

2.3创建对象

定义类的目的就是使用类来创建对象.

在 python 中使用类创建对象与其他语言差别较大, 其他语言需要使用关键字new, python 精简了创建方式, 我们不需要new.

2.3.1 python 就是以函数形式调用来创建对象的!


python 创建对象直接使用类名()就可以了.

class Student:
    pass


s1 = Student()    # 使用类创建对象
print(s1)

创建对象的过程是不是和方法调用一样一样的?!

2.4类定义的深入研究

类必须先定义再使用

类的定义与函数定义是一样的, 都要遵循先定义再使用

s2 = Student()    # 此处无法使用类来创建对象


class Student:
    pass

可以在if语句中甚至函数中定义类

if True:
    class Student:
        pass


s1 = Student()
print(s1)

使用类的时候, 一定要保证类被已经被定义了.


类的主体

类主体中都可以定义什么?

在 python 中类可以定义:


1. 字段(field, 在国内很多人叫属性)

在 python 中字段分 2 种:

  1. 实例变量(Instance Variables):
    他存储的值是属于每一个对象的, 或者对不同的对象来说他们是独立. 就像人的私有财产
  2. 类变量(Class Variables):
    他存储的值是属于类本身的, 而不是属于某一个具体的对象, 或者说他是被所有的对象所共有的. 就像公共财产

2. 方法

方法就是我们以前学习的函数, 只是同类扯上关系了而已!

在 python 中的方法分 3 种:

  1. 实例方法.
    和实例变量一样, 他是属于对象的.
    实例方法相比普通的函数有一个比较特殊的地方:第一个形参总是会自动传入这个实例(对象)
  2. 类方法
    和类变量一样, 是属于类的.
    类方法与实例方法的区别在于第一个参数: 类方法的第一个参数总是这个类本身.
  3. 静态方法
    静态方法和实例没有任何关系. 它仅仅是定义在类中而已, 这个时候类就相当于这个方法的命名空间.

2.4.1类中定义字段

2.4.1.1类变量

类变量表示所有的对象所共有的一种数据.换句话说, 所有的对象都可以直接访问到, 并且他们访问到的是同一个变量(肯定是相同的值!)

把变量直接声明在类的内部的变量.

访问类变量直接通过类名.变量名来访问.

class Student:
    # 直接在类中定义变量,
    # 这样的变量就是类变量(类属性, 类似 java 中的静态属性)
    country = "china"


print(Student.country)
# 修改类变量的值
Student.country = "usa"
print(Student.country)


当然你也可以在任何的地方通过类名.属性=值的方式动态给类添加类属性.

class Student:
    # 直接在类中定义变量,
    # 这样的变量就是类变量(类属性, 类似 java 中的静态属性)
    country = "china"


Student.count = 1   # 动态添加类属性
print(Student.count)

但是, 建议在类中直接定义类属性, 只有在需要的时候才使用动态的方式添加类属性.


2.4.1.2 实例变量

实例变量表示每个对象都自己所独有.

所以, 实例变量与每个具体的对象相关.

添加实例变量:

一般是在一个叫做__init__()的方法里面来添加. (关于方法下节再细讲, 现在你只需要知道他是一个函数就可以了)

__init__(), 注意他是左右分别有 2 个_. 这个方法不需要我们手动去调用, 当你使用类创建对象的时候, 会自动调用这个方法.

这个方法的第 1 个参数永远是创建的那个对象(所有的实例方法都是这样的), 我们可以通过这个参数来向对象中添加属性, 这样的属性就是实例属性.

作为国际惯例, 第 1 个参数的一般都命名为self, 当然你也可以给他起个别的名字, 但是何必呢!


class Student:
    def __init__(self):
        self.name = "李四"
        self.age = 20


s = Student()
print(s.name)
print(s.age)


上面这种写法, 会导致使用这个类创建的对象的nameage这个两个实例变量的值都会初始化为同样的值, 这其实并不好.

我们想每个变量初始化的值都不一样, 可以在创建的对象的是把具体的值沟通过实参传递过去, 则实参会自动传到__init__()方法的第 2 个开始的参数中.

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age


zs = Student("张三", 20)
print(zs.name + " " + str(zs.age))
ls = Student("李四", 30)
print(ls.name + " " + str(ls.age))

你会发现每个对象的值都不一样的!


2.4.1.3 可以通过对象直接访问类变量

python 允许通过对象直接访问到类变量. (有些语言是不允许的, 比如 c#, JavaScript 就不允许, 但是 java 允许)

class Student:
    country = "china"

    def __init__(self, name, age):
        self.name = name
        self.age = age


zs = Student("张三", 20)
print(zs.name + " " + str(zs.age))
ls = Student("李四", 30)
print(ls.name + " " + str(ls.age))

print(zs.country) # 通过对象直接访问类变量
print(ls.country)


2.4.2 类中定义方法

2.4.2.1. 定义实例方法

实例方法和普通方法的区别:

  1. 实例方法必须定义在类中
  2. 实例方法的第一个参数永远是那个具体的对象, 而且不需要调用者手动传入, python 会自动传入那个对象. 而且这个形参一般命名为self
  3. 实例方法调用方式:对象.实例方法(实参)

class Student:
    def __init__(self, name):
        self.name = name

    # 定义一个实例方法:一个参数表示具体的对象, python 会默认传入
    def speak(self):
        print("我的名字是:" + self.name)  # 在实例方法中访问实例变量


s = Student("志玲")
s.speak()


self的理解

学过其他语言的人都知道, python 的 self 其实就是在其他语言的this.

那么self到底指代哪个对象?

通过哪个对象调用的这个实例方法, 那么这个实例方法中的self就指代谁

而且 python 的self一朝绑定, 终身不变. (不像 javascript 中的那个 this 小婊砸随着调用方式的不同而而更改绑定对象, 让你眼花缭乱到怀疑人生)


class Student:
    def __init__(self, name):
        self.name = name

    # 定义一个实例方法:一个参数表示具体的对象, python 会默认传入
    def speak(self):
        print("我的名字是:" + self.name)  # 在实例方法中访问实例变量


s = Student("志玲")
# s.speak 的 this 永远指定的是 s 对象
foo = s.speak  # 重新定义一个变量, 指向了对象 s 的 speak 方法. 
foo()  # 则 self 仍然绑定的是 s 对象


class Student:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("我的名字是:" + self.name)  # 在实例方法中访问实例变量


s1 = Student("志玲")
s2 = Student("凤姐")

s2.speak = s1.speak

s2.speak()

说明:
s1.speak表示的那个方法赋值给s2.speak, 虽然你调用的时候使用的是s2.speak(), 但是他指向的那个方法的self已经永远的绑定到了s1


2.4.2.2. 定义类方法

类方法和实例方法的区别:

  1. 一个方法想成为类方法, 需要在方法的上面要添加一个内置装饰器:@classmethod
  2. 实例方法的第一个参数是具体的对象, 而类方法的第一个参数是类对象.(python 中一切皆对象, 那么类本身也是个对象, 我们一般称之为类对象). 类对象也是 python 自动传递. (类对象一般起名为 cls)
  3. 调用实例方法使用对象.实例方法(实参), 而调用类方法使用类名.类方法(实参)
  4. 类方法中可以访问类变量, 但是不能访问实例变量, 因为没有self啊.

class Student:
    country = "china"

    @classmethod
    def say(cls):
        print("我们的国家是:" + cls.country)

Student.say()


什么时候使用类方法

如果一个方法不需要操作实例变量, 则这个方法建议定义成类方法!


注意:

有一点注意, 类方法也可以通过实例对象来调用, 但是不管怎么调用, 类方法的第一个参数总是类对象!

class Student:
    country = "china"

    @classmethod
    def say(cls):
        print("我们的国家是:" + cls.country)


Student.say()
s = Student()
s.say()


2.3.2.3. 定义静态方法

静态方法其实是一种普通的函数, 他仅仅是处于类的命名空间中.(把当前类作为了他的命名空间, 其他情况与普通函数没有任何区别).

  1. 定义静态方法只需要在函数的上面添加一个装饰器:@staticmethod
  2. 调动静态方法: 类名.静态方法(实参). 只需要把类名作为他的前缀来执行, 与普通函数相比, 没有其他任何多余的操作!

class Student:
    @staticmethod  # 定义静态方法
    def create_student():
        print("我是个静态方法")


Student.create_student()


静态方法的应用场景

因为 python 的类中只有一个__init__()方法, 意味着创建对象的方式只能有一种.

我们可以使用静态方法给外界提供其他的创建对象的方式.


import time
class Date:
    """
    创建一个表示日期的类
    """
	def __init__(self, year, month, day):
        self.year = year
        self.month = month
        self.day = day

    @staticmethod
    def now():
        """
        创建表示当前日期的对象
        :return:
        """
        t = time.localtime()
        return Date(t.tm_year, t.tm_mon, t.tm_mday)

    @staticmethod
    def tomorrow():
        """
        创建表示明日日期的对象
        :return:
        """
        t = time.localtime(time.time() + 60 * 60 * 24)
        return Date(t.tm_year, t.tm_mon, t.tm_mday)

now = Date.now()
print("现在是: %d年%d月%d日" % (now.year, now.month, now.day))
now = Date.tomorrow()
print("明天是: %d年%d月%d日" % (now.year, now.month, now.day))

2.4.3 python中的__init()__方法

在任何一个 python 类中, 都存在一个__init__()的方法, 而且只能存在一个.

我们不管用什么办法创建对象, 都会自动的去执行__init__()方法

默认情况下的__init()__

默认情况, __init()__什么都不做.

__init__()初始化实例变量

__init()__方法的主要作用就是添加并初始化实例变量. 初始化的实例变量的值在创建对象的时候通过实参传递过来.

__init__()的第一个形参总是新创建的那个实例对象.

以上是关于Python第七章-面向对象的主要内容,如果未能解决你的问题,请参考以下文章

Python第七章-面向对象

进击的Python第七章:Python的高级应用面向对象编程进阶

Python之路第七篇--Python基础之面向对象及相关

Python开发第七章:Python面向对象进阶

Python基础-第七天-面向对象编程进阶和Socket编程简介

python之旅六第七篇面向对象之类成员