Python第七章-面向对象
平仄平仄平平仄 人气:1
# 面向对象编程基础
## 一、面向对象概念
### 1.1 什么是面向过程
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
生活中的的例子举例。
### 1.2 什么是面向对象
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
1. **面向对象是一种思维方法**
2. **面向对象是一种编程方法**
3. **面向对象并不只针对某一种编程语言**
### 1.3 面向对象和面向过程的区别和联系
> **面向过程，做什么**
>
> 面向过程过程侧重整个问题的解决步骤，着眼局部或者具体，**核心：过程的实现**
>
> 【面向过程】：
> 为了把大象装进冰箱，需要3个过程。
> 1) 把冰箱门打开（得到打开门的冰箱）
> 2) 把大象装进去（打开门后，得到里面装着大象的冰箱）
> 3) 把冰箱门关上（打开门、装好大象后，获得关好门的冰箱）
> 每个过程有一个阶段性的目标，依次完成这些过程，就能把大象装进冰箱。
> **面向对象，谁来做**
>
> 面向对象侧重具体的功能，让某个对象具有这样的功能。更加侧重于整体。**核心：对象**
>
> 【面向对象】：
> 为了把大象装进冰箱，需要做三个动作（或者叫行为）。
> 每个动作有一个执行者，它就是对象。
> 1) 冰箱，你给我把门打开
> 2) 大象，你给我钻到冰箱里去
> 3) 冰箱，你给我把门关上
> 依次做这些动作，就能把大象装进冰箱。
```python
各自的优缺点
面向过程的优点：
流程化使得编程任务明确，在开发之前基本考虑了实现方式和最终结果；
效率高,面向过程强调代码的短小精悍，善于结合数据结构来开发高效率的程序。。
流程明确，具体步骤清楚，便于节点分析。
缺点是：需要深入的思考，耗费精力，代码重用性低，扩展能力差，维护起来难度比较高，
对复杂业务来说，面向过程的模块难度较高，耦合度也比较高。
面向对象的优点：结构清晰，程序便于模块化，结构化，抽象化，更加符合人类的思维方式；
封装性，将事务高度抽象，从而便于流程中的行为分析，也便于操作和自省；
容易扩展，代码重用率高，可继承，可覆盖；
实现简单，可有效地减少程序的维护工作量，软件开发效率高。
缺点是：效率低，面向对象在面向过程的基础上高度抽象，从而和代码底层的直接交互非常少机会，
从而不适合底层开发和游戏甚至多媒体开发；
复杂性，对于事务开发而言，事务本身是面向过程的，过度的封装导致事务本身的复杂性提高。
```
编程语言对面向对象的实现主流的有两种方式：基于类的面向对象和基于原型的面向对象。
不管以什么方式实现，都具有面向对象的三大特征：
- 封装
也就是把客观事物封装成抽象的类或具体的对象，并且类或对象可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
- 继承
可以让某个类型的对象获得另一个类型的对象的属性的方法
- 多态
不同实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。
### 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`来定义类
```python
class 类名:
# 类中定义的内容
```
------
比如我们定义一个表示学生的`Student`类:
```python
class Student:
pass
```
说明:
1. `class` 后面紧跟类名. 类名的命名使用驼峰命名法.
2. 类名的后面跟一个冒号
3. 然后是带有正确缩进的类的主体.\(上面的例子中使用 `pass`, 表示空的类主体\)
### 2.3创建对象
定义类的目的就是使用类来创建对象.
在 python 中使用类创建对象与其他语言差别较大, 其他语言需要使用关键字`new`, python 精简了创建方式, 我们不需要`new`.
#### 2.3.1 python 就是以函数形式调用来创建对象的!
------
python 创建对象直接使用`类名()`就可以了.
```python
class Student:
pass
s1 = Student() # 使用类创建对象
print(s1)
```
**创建对象的过程是不是和方法调用一样一样的?!**
### 2.4类定义的深入研究
**类必须先定义再使用**
类的定义与函数定义是一样的, 都要遵循先定义再使用
```python
s2 = Student() # 此处无法使用类来创建对象
class Student:
pass
```
**可以在`if`语句中甚至函数中定义类**
```python
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类变量
类变量表示所有的对象所共有的一种数据.换句话说, 所有的对象都可以直接访问到, 并且他们访问到的是同一个变量(肯定是相同的值!)
**把变量直接声明在类的内部的变量.**
访问类变量直接通过`类名.变量名`来访问.
```python
class Student:
# 直接在类中定义变量,
# 这样的变量就是类变量(类属性, 类似 java 中的静态属性)
country = "china"
print(Student.country)
# 修改类变量的值
Student.country = "usa"
print(Student.country)
```
------
当然你也可以在任何的地方通过`类名.属性=值`的方式动态给类添加类属性.
```python
class Student:
# 直接在类中定义变量,
# 这样的变量就是类变量(类属性, 类似 java 中的静态属性)
country = "china"
Student.count = 1 # 动态添加类属性
print(Student.count)
```
但是, 建议在类中直接定义类属性, 只有在需要的时候才使用动态的方式添加类属性.
------
##### 2.4.1.2 实例变量
实例变量表示每个对象都自己所独有.
所以, 实例变量与每个具体的对象相关.
**添加实例变量:**
一般是在一个叫做`__init__()`的方法里面来添加. (关于方法下节再细讲, 现在你只需要知道他是一个函数就可以了)
`__init__()`, 注意他是左右分别有 2 个`_`. 这个方法不需要我们手动去调用, 当你使用类创建对象的时候, 会自动调用这个方法.
这个方法的第 1 个参数永远是创建的那个对象(所有的实例方法都是这样的), 我们可以通过这个参数来向对象中添加属性, 这样的属性就是实例属性.
作为国际惯例, 第 1 个参数的一般都命名为`self`, 当然你也可以给他起个别的名字, 但是何必呢!
------
```python
class Student:
def __init__(self):
self.name = "李四"
self.age = 20
s = Student()
print(s.name)
print(s.age)
```
------
上面这种写法, 会导致使用这个类创建的对象的`name`和`age`这个两个实例变量的值都会初始化为同样的值, 这其实并不好.
我们想每个变量初始化的值都不一样, 可以在创建的对象的是把具体的值沟通过实参传递过去, 则实参会自动传到`__init__()`方法的第 2 个开始的参数中.
```python
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 允许)
```python
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. 实例方法调用方式:`对象.实例方法(实参)`
------
```python
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` 小婊砸随着调用方式的不同而而更改绑定对象, 让你眼花缭乱到怀疑人生)
------
```python
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 对象
```
------
```python
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`啊.
------
```python
class Student:
country = "china"
@classmethod
def say(cls):
print("我们的国家是:" + cls.country)
Student.say()
```
------
**什么时候使用类方法**
如果一个方法不需要操作实例变量, 则这个方法建议定义成类方法!
------
**注意:**
有一点注意, 类方法也可以通过实例对象来调用, 但是不管怎么调用, 类方法的第一个参数总是类对象!
```python
class Student:
country = "china"
@classmethod
def say(cls):
print("我们的国家是:" + cls.country)
Student.say()
s = Student()
s.say()
```
------
##### 2.3.2.3. 定义静态方法
静态方法其实是一种普通的函数, 他仅仅是处于类的命名空间中.(把当前类作为了他的命名空间, 其他情况与普通函数没有任何区别).
1. 定义静态方法只需要在函数的上面添加一个装饰器:`@staticmethod`
2. 调动静态方法: `类名.静态方法(实参)`. 只需要把类名作为他的前缀来执行, 与普通函数相比, 没有其他任何多余的操作!
------
```python
class Student:
@staticmethod # 定义静态方法
def create_student():
print("我是个静态方法")
Student.create_student()
```
------
**静态方法的应用场景**
因为 python 的类中只有一个`__init__()`方法, 意味着创建对象的方式只能有一种.
我们可以使用静态方法给外界提供其他的创建对象的方式.
------
```python
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__()`的第一个形参总是新创建的那个实例对象.
加载全部内容