Python基础 - 8.面向对象编程

面向对象和面向过程

面向过程：C、Basic、汇编

面向对象：C++、Java、PHP

面向过程是从计算机的角度出发考虑问题

面向对象是从人的角度出发考虑问题

比如：学生去教室上课

面向过程：

起床
洗刷刷
穿衣服
吃早餐
出门，往教室方向走
if 遇到红灯:
   while 红灯亮:
     等待直到绿灯
If 遇到漂亮妹子：
  搭讪
到了教室
while 上课时间未到：
  等待
开始上课
while 下课时间未到：
  吃饭
  睡觉
  打豆豆
下课

面向对象：

定义学生类
定义学生类的属性：姓名、年龄、身高、专业、班、学号、……
定义学生类的方法：吃饭()、睡觉()、上课()、下课()
定义教室类
定义教室类的属性：位置、容量、网络状态
定义教室类的方法：开门()、关门()、……
创建一个学生类的对象 yangbing
创建一个教室类的对象 204
执行学生的上课的方法 yangbing.上课(204)

面向过程由于适用于底层软件

相对面向过程来说，面向对象更适合组建大团队工作，适用于上层的软件。

面向对象是从第三者的角度出发来考虑问题。

面向对象和面向过程是不同的编程思维，在不同的场合下使用，看问题的角度不同。不能绝对说谁优谁劣

常用面向对象编程语言的区别

C++、Java、Python

Java：纯粹的面向对象编程语言。里面没有任何的面向过程的东西。

public class Test {
  public static void main() {
    System.out.println(“hello”):
  }
}

任何的代码都必须在类里面去编程，脱离了类就什么都没有了

C++：在C语言的基础上，加上面向对象的概念（C加面向对象）

int main() {
  printf(“hello”);
}

Python：面向过程或面向对象

print("hello") 

什么是对象

Python没有new

程序猿没有对象怎么办？自己new一个

天上飞的：飞机、大炮、小鸟……

地上跑的：蛇、牛、羊、猪、……

水里游的：鱼、虾、蟹、……

抽象的：规则、项目、方法……

世界上万事万物都是对象

如何区分类和对象

思考下面的话：

• 1 狗是类 狗是对象

• 2 yangbing是类 yangbing是对象

对象是具体的；类是抽象的。

• 一个类中可以包含多个对象

• 类是某一系列对象的集合（总称）

声明类和创建对象

OOP：Object Oriented Programming（面向对象编程）

OOA、OOD、OOP：

Python中创建类的方式：

class 类名:
   类中的代码

约定的习俗：类名首字母大写。比如：

class Dog:
    pass

Python中创建对象的方式

对象名 = 类名()

比如：

# dog1是Dog的对象
dog1 = Dog()
print(dog1) # <__main__.Dog object at 0x000001CAA988FE48>
print(type(dog1)) # <class '__main__.Dog'>

Dog是类

dog1是对象。dog1是Dog的对象

我们是在面向对象编程，实际上是对dog1编程。

属性

属性就是对象所拥有的特性。通过如下方法设置

对象.属性 = 属性值

比如：

class Dog:
    pass


dog1 = Dog()
dog1.name = '旺财' # 姓名
dog1.age = 13 # 年龄
dog1.sex = 'male' # 性别
print(dog1.name)
print(dog1.age)
print(dog1.sex)

如果想要查看类里面的所有属性和方法，可以通过dir()去查看

print(dir(dog1))
dog1.name = '旺财' # 姓名
dog1.age = 13 # 年龄
dog1.sex = 'male' # 性别
print(dir(dog1))

留意输出的结果：

留意两次运行的结果，后面多了name、age、sex。说明新的属性被添加到类中了。

方法

方法是类的对象所拥有的一系列的操作。

我们一般会在类中定义方法

def 方法名(方法的参数):
  方法的实现代码

注意：方法名首字母小写。比如：

class Dog:
    # 狗的吃饭的方法
    def eat(self):
        print('狗吃肉')
    # 狗叫的方法
    def bark(self):
        print('旺')

dog1 = Dog()
dog1.eat()
dog1.bark()

方法跟函数有点类似：

• 函数是独立的概念，是单独存在的。方法则是地属于类的概念，脱离了类方法就没有意义
• 函数可以没有参数。方法至少得有一个参数self（Java中的this），表示当前对象本身
• 如果要在方法中访问类的属性，需要通过如下方式编写：

self.属性名

比如：

class Dog:
    # 狗的吃饭的方法
    def eat(self):
        print('狗吃肉')
    # 狗叫的方法
    def bark(self):
        print('旺')
    # 打印狗的信息
    def info(self):
        print("姓名:%s,年龄:%d" % (self.name, self.age))

dog1 = Dog()
dog1.eat()
dog1.bark()
dog1.name = '旺财' # 姓名
dog1.age = 13 # 年龄
dog1.info()

如果要给方法传递参数，参数写到方法的self参数的后面

class Dog:
    # 狗的吃饭的方法
    def eat(self):
        print('狗吃肉')
    # 狗叫的方法
    def bark(self):
        print('旺')
    # 打印狗的信息
    def info(self):
        print("姓名:%s,年龄:%d" % (self.name, self.age))
    # 设置狗的名字
    def set_name(self, name):
        # self.name表示狗的name属性
        # name表示传入的参数
        self.name = name 

dog1 = Dog()
dog1.eat()
dog1.bark()
#dog1.name = '旺财' # 姓名
dog1.set_name('旺财') 
dog1.age = 13 # 年龄
dog1.info()

方法也可以有返回值，这点与函数一样

class Dog:
    # 狗的吃饭的方法
    def eat(self):
        print('狗吃肉')
    # 狗叫的方法
    def bark(self):
        print('旺')
    # 打印狗的信息
    def info(self):
        print("姓名:%s,年龄:%d" % (self.name, self.age))
    # 设置狗的名字
    def set_name(self, name):
        # self.name表示狗的name属性
        # name表示传入的参数
        self.name = name 
    # 读取狗的名字
    def get_name(self):
        return self.name

dog1 = Dog()
dog1.eat()
dog1.bark()
#dog1.name = '旺财' # 姓名
dog1.set_name('旺财') 
dog1.age = 13 # 年龄
dog1.info()
name = dog1.get_name()
print(name)

注意：在Python中没有重载的概念。类中的方法名字必须是唯一的。

init__和__del

• __init__是一个方法。是python系统中自带的方法。

• 该方法至少也需要带一个参数self

• 该方法表示：初始化的操作。

• 当创建类的对象的时候，就会调用__init__方法。

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name, age):
        self.name = name
        self.age = age

dog1 = Dog('旺财', 13)
print(dog1.name)
print(dog1.age)

Java中的构造方法是否对应python中的__init__？不是

另外，当用户调用del命令去删除对象的时候，会触发__del__方法的调用。

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # 销毁
    def __del__(self):
        print('__del__')
        self.name = ''
        self.age = 0

dog1 = Dog('旺财', 13)
print(dog1.name)
print(dog1.age)

del dog1
print('over')

如果程序中没有del，在程序结束后，python会触发gc垃圾回收机制，将不用的变量全部释放，所以在程序结束后对应的__del__才会被执行。

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # 销毁
    def __del__(self):
        print('__del__')
        self.name = ''
        self.age = 0

dog1 = Dog('旺财', 13)
print(dog1.name)
print(dog1.age)

del dog1
print('over')

运行的结果：

思考：

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # 销毁
    def __del__(self):
        print('__del__')
        self.name = ''
        self.age = 0

dog1 = Dog('旺财', 13)
dog2 = dog1

del dog1
print('over')

现在dog2指向dog1，那么__del__是在del的时候执行，还是在程序结束后执行？

程序结束后再调用

每个类有一个引用计数，描述有多少个对象指向它。

只有当引用计数值为0的时候，才会调用__del__。

print('---0---')
del dog1
print('---1---')
del dog2
print('---2---')

str

如果声明一个类的对象后，想要打印该对象的信息，可以通过重写__str__方法，指定返回值来实现。

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name, age):
        self.name = name
        self.age = age
    # __str__必须返回一个字符串
    def __str__(self):
        return self.name + "," + str(self.age)

dog1 = Dog('旺财', 13)
print(dog1)

私有

Private protected public 3P

Python中描述私有属性和私有方法，通过前置下划线表示：

• _xxx：单前置下划线。

• __xxx：双前置下划线。

• _xxx_：双前置双后置下划线。类的内部定义好的。一般不让外界直接调用。

一般常用双前置下划线。

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name):
        self.name = name
        self.__age = 0 # age私有
    # __str__必须返回一个字符串
    def __str__(self):
        return self.name + "," + str(self.__age)

dog1 = Dog('旺财')
dog1.__age -= 20
print(dog1)

此时，运行程序，会报错。__age找不到该属性

同样可以把方法私有化

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name):
        self.name = name
        self.__age = 0 # age私有
    # __str__必须返回一个字符串
    def __str__(self):
        return self.name + "," + str(self.__age)

    # age的get方法
    def get_age(self):
        return self.age

    # age的set方法
    def __set_age(self, age):
        self.__age = age
        
    # yearPass过了一年
    def year_pass(self):
        self.set_age(self.__age + 1)

dog1 = Dog('旺财')
dog1.__set_age(-20)
print(dog1)

如果强行调用，会报错

对象的引用计数

import sys

class Dog:
    # 初始化(两个下划线)
    def __init__(self, name):
        self.name = name
        self.__age = 0 # age私有


dog1 = Dog('旺财')
print(sys.getrefcount(dog1))

运行结果为：

这里得出的结果比实际结果要多1，需要自行减去1。

练习

1. 定义一个类Cat：

• 1 通过初始化方法传入猫的姓名（加肥猫、叮当猫、HelloKitty猫）。年龄初始化为0

• 2 定义一个方法yearPass()，表示过了一年，方法中让年龄增加1。

• 3 重写__str__方法，打印猫的姓名和年龄

• 4 定义并创建猫的对象，传入姓名。然后每调用一次yearPass()，就打印一下猫的信息

• 5 每过几年，就给猫添加饰物；3岁添加衣服、5岁添加脚垫、8岁添加铃铛、10岁剪胡子。在__str__方法中，把添加的饰物都打印出来

   汤姆，1岁，无饰物

   …………

   汤姆，3岁，衣服

   ……

   汤姆，9岁，衣服、脚垫、铃铛

   ……

   汤姆，11岁，衣服、脚垫、铃铛、剪胡子

2 根据如图所示，类之间的关系，写出对应的代码

3 定义一个类Point，描述三维空间的一个点。属性包括x、y、z的值。

• 添加两个方法，描述当前点与另外一个点之间的曼哈顿距离与欧氏距离

• 添加两个函数，描述任意两个点之间的曼哈顿距离与欧氏距离

本章项目源码

URL：https://gitee.com/yuanbaonet/master_python/tree/baoai_python_v8/

对应版本：baoai_python_v8

对应文件：sample/python/p8.py