Python第七章-面向对象初级
面向对象编程基础
一、面向对象概念
1.1 什么是面向过程
就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。
生活中的的例子举例。
1.2 什么是面向对象
面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
- 面向对象是一种思维方法
- 面向对象是一种编程方法
- 面向对象并不只针对某一种编程语言
1.3 面向对象和面向过程的区别和联系
面向过程，做什么
面向过程过程侧重整个问题的解决步骤，着眼局部或者具体，核心：过程的实现
【面向过程】：
为了把大象装进冰箱，需要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先有对象还是先有类
看情况:
- 在做面向对象分析的时候, 一般是先有对象, 然后把对象的共性抽象出来, 然后就形成了类.
- 编写代码的时候, 一般是先完成类的编写, 然后在需要的时候创建对象就可以了.
2.2 定义类
我们需要关键字class来定义类
class 类名:
# 类中定义的内容
比如我们定义一个表示学生的student类:
class student:
pass
说明:
-
class后面紧跟类名. 类名的命名使用驼峰命名法. - 类名的后面跟一个冒号
- 然后是带有正确缩进的类的主体.(上面的例子中使用
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 种:
- 实例变量(instance variables):
他存储的值是属于每一个对象的, 或者对不同的对象来说他们是独立. 就像人的私有财产 - 类变量(class variables):
他存储的值是属于类本身的, 而不是属于某一个具体的对象, 或者说他是被所有的对象所共有的. 就像公共财产
2. 方法
方法就是我们以前学习的函数, 只是同类扯上关系了而已!
在 python 中的方法分 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)
上面这种写法, 会导致使用这个类创建的对象的name和age这个两个实例变量的值都会初始化为同样的值, 这其实并不好.
我们想每个变量初始化的值都不一样, 可以在创建的对象的是把具体的值沟通过实参传递过去, 则实参会自动传到__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. 定义实例方法
实例方法和普通方法的区别:
- 实例方法必须定义在类中
- 实例方法的第一个参数永远是那个具体的对象, 而且不需要调用者手动传入, python 会自动传入那个对象. 而且这个形参一般命名为
self - 实例方法调用方式:
对象.实例方法(实参)
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. 定义类方法
类方法和实例方法的区别:
- 一个方法想成为类方法, 需要在方法的上面要添加一个内置装饰器:
@classmethod - 实例方法的第一个参数是具体的对象, 而类方法的第一个参数是类对象.(python 中一切皆对象, 那么类本身也是个对象, 我们一般称之为类对象). 类对象也是 python 自动传递. (类对象一般起名为
cls) - 调用实例方法使用
对象.实例方法(实参), 而调用类方法使用类名.类方法(实参) - 类方法中可以访问类变量, 但是不能访问实例变量, 因为没有
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. 定义静态方法
静态方法其实是一种普通的函数, 他仅仅是处于类的命名空间中.(把当前类作为了他的命名空间, 其他情况与普通函数没有任何区别).
- 定义静态方法只需要在函数的上面添加一个装饰器:
@staticmethod - 调动静态方法:
类名.静态方法(实参). 只需要把类名作为他的前缀来执行, 与普通函数相比, 没有其他任何多余的操作!
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__()的第一个形参总是新创建的那个实例对象.