Python入门——面向对象编程

Python入门——面向对象编程

欢迎给我邮箱一起共同学习python一起进步:

1. 常见的编程方式

1.1 函数式编程

函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。

和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。和过程化编程相比，函数式编程里函数的计算可随时调用。

简单定义：“函数式编程"是一种"编程范式”（programming paradigm），也就是如何编写程序的方法论。

它属于"结构化编程"的一种，主要思想是把运算过程尽量写成一系列嵌套的函数调用。

• 函数是"第一等公民"

  所谓"第一等公民"（first class），指的是函数与其他数据类型一样，处于平等地位，可以赋值给其他变量，也可以作为参数，传入另一个函数，或者作为别的函数的返回值。

• 没有"副作用"

  所谓"副作用"（side effect），指的是函数内部与外部互动（最典型的情况，就是修改全局变量的值），产生运算以外的其他结果。

• 优点

  1. 代码简洁，开发快速
  2. 接近自然语言，易于理解
  3. 更方便的代码管理
  4. 易于"并发编程"
  5. 代码的热升级——>函数式编程没有副作用，只要保证接口不变，内部实现是外部无关的

1.2 面向对象编程

​ 面向对象程序设计(Object Oriented Programming)作为一种新方法，其本质是以建立模型体现出来的抽象思维过程和面向对象的方法。模型是用来反映现实世界中事物特征的。任何一个模型都不可能反映客观事物的一切具体特征，只能对事物特征和变化规律的一种抽象，且在它所涉及的范围内更普遍、更集中、更深刻地描述客体的特征。通过建立模型而达到的抽象是人们对客体认识的深化。

• OOP=对象+类+继承+多态+消息，其中核心概念是类和对象。

• 特点：

  1. 封装：把数据和操作数据的函数从逻辑上组装成一个整体（对象）。隐藏实现细节，暴露简单的调用接口。
  2. 继承：扩展已有的类创建新的类，实现对已有的类的代码的复用
  3. 多态：给不同对象发送相同的消息，执行返回不同的结果。子类对父类原有的方法进行重写。

2. 对象

• 万事万物皆为对象
• 对象表示一个实实在在存在的物体是独一无二的
• 对象都有自己的属性和方法
• 对象都可以归为具体某个类
• 对象是可以接收信息的实体，面向对象编程就是通过对象接受消息来达到解决问题的要求

3. 类

• 将有共同特征（静态特征和动态特征）的对象的共同特征抽取出来之后得到的一个抽象概念
• 同时类也可以是一个对象
• 对象是类的实例

4. 面向对象编程步骤

• 定义类
  1. 数据抽象————找到对象的静态特征
  静态特征-——>对象的属性，找名词
  2. 行为抽象————找到对象的动态特征
  动态特征————> 对象的方法，找动词
  这两步是难点也是重点
• 创建对象
• 发消息

4.1 创建对象实例

• 创建一个学生类

class Student:
    # 数据抽象
    def __init__(self, name, age):
        """初始化数据

        :param name:
        :param age:
        """
        self.name = name
        self.age = age

    # 行为抽象
    def eat(self):
        """吃饭"""
        print(f'{self.name}正在吃饭')

    def study(self, course_name):
        """学习"""
        print(f'{self.name}正在学习{course_name}')

    def play(self, game_name):
        """玩游戏"""
        print(f'{self.name}正在玩{game_name}')

    def watch_av(self):
        """看电影"""
        if self.age < 18:
            print(f'{self.name}未满18岁')
        else:
            print(f'随便看')

• 创建对象及发送消息

from example02 import Student

if __name__ == '__main__':
    stu1 = Student('tian', 22) # 创建一个stu1对象，其中属性name:tian,age:22
    stu2 = Student('yu', 23)
    # Student.study(stu1, 'English')
    stu1.study('English') # 通过stu1对象调用study方法
    stu2.play('打牌')
    stu2.name = '小天'
    stu2.age = 12 # 修改stu2的age属性值
    stu2.watch_av()
    print(stu2.name, stu2.age) # 打印stu2的name和age属性对应的值

4.2静态方法和类方法

我们在类里面写的函数，通常称之为方法，它们基本上都是发给对象的消息。
但是有的时候，我们的消息并不想发给对象，而是希望发给这个类（类本身也是一个对象），
这个时候，我们可以使用静态方法或类方法。

• 静态方法 - 发给类的消息 —> @staticmethod —> 装饰器

# 定义一个静态方法
    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

• 类方法 - 发给类的消息 —> @classmethod —> 装饰器 —> 第一个参数（cls）是接收消息的类

 # 定义一个类的类方法
    @classmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

4.3 继承和重写

• 扩展以有类来创建新的类，实向对代码的复用。这种过程就叫重写。
• 子类对父类已有的方法进行重新定义返回值，有就是对原有吧版本进行一个更新，这个过程就叫重写。

class Person:

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

    def eat(self):
        print(f'{self.name}正在吃饭！')

    def sleep(self):
        print(f'{self.name}睡觉')
        
    def do_work(self):
        pass
    

class Student(Person):
    
    def __init__(self, name, sex, grad):
        super().__init__(name, sex)
        self.grad = grad
        
    def do_work(self):
        return f'work_hard study day and day'


class  Teacher(Person):
	
	def __init__(self, name, sex, book):
        super().__init__(name, sex)
        self.book = book
        
	def do_work(self):
	return f'教{self.book}课' 
        

• 上述代码中Student 继承了Person类同时重写了Person中的do_work方法。
• 同一方法在不同类中，给对象发消息实现了不同的结果就叫多态。多态是面向对象编写最重要的。

总结

面向对象编程的思想通过向对象发送消息来实现达到解决问题，最重要的就是对象。面向对象编程最难最重要的就是定义类，类中包括了对象的属性和方法。面向对象编程对比其它编程范式带来很高的编程效率，提高模块的独立性。