python—面向对象

86 阅读 0 评论 57 点赞

我是靠谱客的博主含糊时光，最近开发中收集的这篇文章主要介绍python—面向对象，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

面向对象和面向过程

面向过程

面向过程”(Procedure Oriented)是一种以过程为中心的编程思想，这些都是以什么正在发生为主要目标进行编程。就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

1.把完成某一个需求的所有步骤从头到尾逐步实现
2.根据开发要求，将某些功能独立的代码封装成一个又一个函数
3.最后完成的代码，就是顺序的调用不同的函数

特点：
1.注重步骤和过程，不注重职责分工
2.如果需求复杂，代码变得非常复杂
3.开发复杂的项目的时候，没有固定的套路，开发难度很大

面向对象

面向对象编程——Object Oriented Programming，简称OOP，是一种程序设计思想。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

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

面向对象是更大的封装，根据职责在一个类中封装多个方法
1.在完成某一个需求前，首先确定职责–要做的事(方法)
2.根据职责确定不同的对象，在对象内部封装不同的方法(多个)
3.最后完成代码，就是顺序的让不同的对象调用不同的方法
特点：
1.注重对象和职责，不同的对象承担不同的职责
2.更加适合对复杂的需求变化，是专门应对复杂项目的开发，提供固定的套路

类的结构

术语–实例
1.使用面向对象开发，第一步是设计类
2.使用类名() 创建对象，创建对象的动作有两步
1.在内存中为对象分配空间
2.调用初始化方法__init___ 为对象初始化
3.对象创建后，内存中就有了一个对象的实实在在的存在–实例
因此：
1.创建出来的对象叫做类的实例
2.创建对象的动作叫做实例化
3.对象的属性叫做实例属性
4.对象调用的方法叫做实例方法
在程序执行时：
1.对象各自拥有自己的实例属性
2.调用对象的方法，可以通过self
访问自己的属性
调用自己的方法
结论:
1.每一个对象都有自己独立的内存空间，保存各自不同的属性
2.多个对象的方法，在内存中之有一份，在调用方法时，
需要把对象的引用传递到方法内部

1 、类和对象

面向对象最重要的概念就是类（Class）和实例（Instance）。

类是抽象的模板，是一类具有相同特征或行为的事物的一个统称，其中封装着许多的属性以及方法，

实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同，各个实例拥有的数据都互相独立，互不影响

类和对象的关系：先有类再有对象；类是模板对象是根据这个模板创建出来的，类只需要有一个可以实例化出来的对象有多个

1 类的定义
定义类是通过class关键字

类是一类具有相同特征或行为的事物的一个统称，所以在定义类的时候，需要定义一个类名。同时定义属性和方法。提示：需求中没有涉及的属性或方法在设计类时，不需要考虑

类名：这类具有相同特征的事物的名字。命名采用大驼峰命名法：1：每个单词的首字母大写；2：单词与单词之间没有下划线

名词提炼法分析整个业务流程，出现的名词，通常就是找到的类

属性：这个类创建出来的对象有什么特征

对象的特征描述，通常可以定义成属性

方法: 这个类创建出来的对象有什么行为

对象具有的行为(动词)，通常可以定义为方法

示例：1 根据下面信息创建类
小明今年18岁身高1.80 每天早上要跑步，会去吃东西
小张今年17岁身高1.85 小张不跑步小张喜欢吃东西

类名：小张和小明都是人，可以定义成人类（Person）
属性：文中提到的特征：姓名（name）年龄（age）身高（hight）
方法：文中提到的动作：跑步（run）吃东西（eat）

class Person:
    def __init__(self,name,age,hight):
        self.name = name
        self.age = age
        self.hight = hight
    def eat(self):
        print('吃东西')
    def run(self):
        print('跑步')

2 黄颜色的狗叫大黄，看见陌生人汪汪叫，看见主人摇尾巴
类名：狗（Dog）
属性：颜色（color）名称（name）
方法：叫（shout）摇尾巴（shake）

class Dog:
    def __int__(self,name,color):
        self.name = name
        self.color = color
    def shout(self):
        print('汪汪叫～～～')
    def shake(self):
        print('摇尾巴～～～')

2 在创建类定义方法时候的self参数

哪一个对象调用的方法，self就是哪一个对象的引用，在封装的方法内部，self就表示当前调用方法对象自己，在调用方法的时候，程序员不需要传递self参赛(定义的时候，第一个参数必须是self)

class Cat:
    def __init__(self,name,color):
        self.name = name
        self.color = color
    def get_name(self):
        print('name is %s' %self.name)
    def get_color(self):
        print('color is %s' %self.color)

tom = Cat('Tom','blue')
erpang = Cat('pang','yellow')   # 实例化两个对象
#两个对象是使用同一个类创建出来的，但是其数据不一致，相互之间没有关系

tom.get_color()  # 当对象调用方法的时候，其中self参数就是调用方法的对象本身
tom.get_name()

erpang.get_color()# 当对象调用方法的时候，其中self参数就是调用方法的对象本身
erpang.get_name()

输出结果：
color is blue
name is Tom  
 #当调用方法的对象是tom的时候，self参数就是引用的该对象，输出都是实例化该对象的时候，设置的属性

color is yellow
name is pang
 #当调用方法的对象是erpang的时候，self参数就是引用的该对象，输出都是实例化该对象的时候，设置的属性

3 特殊方法 __init__ ：初始化方法：

这个初始化方法是内置方法，是专门用来定义一个类据有哪些属性和方法的
由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把name，score等属性绑上去
注意到__init__方法的第一个参数永远是self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。
有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器自己会把实例变量传进去。

使用：类名（） 就可以创建一个对象，在创建对象的时候，python解释器会自动执行以下操作：1.为对象在内存中分配空间–创建对象；2.调用初始化方法为对象的属性设置初始值。

在创建对象的时候就设置对象的属性。使用默认的初始化方法对属性进行设置。

1.把希望设置的属性值，定义成__init__方法的参数
2.在方法内部使用self.属性名 = 形参接收外部传递的参数
3.在创建对象的时候，使用类名(属性)调用

class Cat:
    def __init__(self,name,color):
        #使用初始化方法直接设置对象的属性name以及color
        self.name = name 
        self.color = color  # 使用属性接收形参
    def get_name(self):
        print('name is %s' %self.name)
    def get_color(self):
        print('color is %s' %self.color)

tom = Cat('tom','blue')  # 

print(tom.color)  # 直接使用对象.属性的方式调用设置好的属性
print(tom.name)

在使用类示例化对象之后，使用对象设置自己的属性。

class Cat:
    def eat(self):
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫爱喝酒')
tom = Cat()   # 示例化一个对象

tom.name = 'Tom'
tom.color = 'blue'   #  直接给对象.属性进行赋值

print(tom.name)

4 特殊方法： __str__

希望使用print输出对象变量的时候，能够打印自定义内容就可以利用__str__这个内置的方法了。但是输出的内容只能是字符串类型。

使用print输出对象变量时候，默认情况会输出这个变量引用的对象是由哪一个类创建的对象以及在内存中的地址

默认输出：

class Cat:
    def eat(self):
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫爱喝酒')
tom = Cat()
print(tom)

#输出结果：
<__main__.Cat object at 0x7f931bf5d7f0>
#  创建对象的类               内存地址

自定义输出：

class Cat:
    def __str__(self):
        return '这是一只喜欢吃鱼喝酒的蓝色tom猫'
    def eat(self):
        print('小猫爱吃鱼')
    def drink(self):
        print('小猫爱喝酒')
tom = Cat()
print(tom)

#输出结果：
这是一只喜欢吃鱼喝酒的蓝色tom猫

5 特殊方法：__del__

如果类中定义__del__方法，那么当使用这个类实例化出来的对象在被删除的时候(把这个对象从内存中删除掉），会自动调用该方法。

class Cat:
    def __init__(self,name):
        self.name = name
    def __del__(self):
        print('%s 就要被删除了' %self.name)  # 使用该特殊方法，当对象被删除的时候调用该方法
    def eat(self):
        print('小猫爱吃鱼')
tom = Cat('Tom')
tom.eat()  
del tom  # 在内存中删除对象
tom.eat()

#输出结果：
小猫爱吃鱼  
Tom 就要被删除了  #在删除 对象的时候调该特殊方法
NameError: name 'tom' is not defined  # 对象已经在内存中被删除，出现报错。

应用练习

使用列表，模拟栈数据结构，包括：入栈，出栈，取栈顶元素，显示栈数据个数，显示栈内数据内容。

class stack:
    def __init__(self):
        self.stacl_list = []  # 初始化一个列表，由来存放数据模拟栈结构
    def push(self,value):# 定义方法，模拟入栈
        self.stacl_list.append(value)
    def pop(self):  # 定义方法，模拟出栈
        if self.stacl_list:
            item = self.stacl_list.pop()
            return item
        else:
            return False
    def top(self):  #取栈顶元素
        if self.stacl_list:
            item = self.stacl_list[-1]
            return item
        else:
            return False
    def length(self):  # 元素个数
        return len(self.stacl_list)
    def view(self):  # 显示所有元素
        return ';'.join(self.stacl_list)