Python

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>>

一、概述

1、面向过程编程

面向过程编程往往用一长段代码来实现指定功能，在开发过程中最常见的操作就是复制粘贴，即：将之前实现的代码块复制到现需功能处。

while True：
    if cpu利用率 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
  
    if 硬盘使用空间 > 90%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接
  
    if 内存占用 > 80%:
        #发送邮件提醒
        连接邮箱服务器
        发送邮件
        关闭连接

2、函数式编程

将具有相同功能的代码写到一个函数中，当需要时，调用、执行这个函数

def 发送邮件(内容)
    #发送邮件提醒
    连接邮箱服务器
    发送邮件
    关闭连接
  
while True：
  
    if cpu利用率 > 90%:
        发送邮件('CPU报警')
  
    if 硬盘使用空间 > 90%:
        发送邮件('硬盘报警')
  
    if 内存占用 > 80%:
        发送邮件('内存报警')

3、面向对象编程

面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）

面向对象编程是一种编程方式，此编程方式需要使用 “类” 和 “对象” 来实现，所以，面向对象编程其实就是对 “类” 和 “对象” 的使用。

类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
对象则是根据模板创建的实例，通过实例对象可以执行类中的函数

# 创建类
class Foo:
    # 创建类中的函数
    def bar(self):
        # do something
        print("bar")
    
    def hello(self, name):
        self.name = name
        print("My name is :%self.name")
# 根据类Foo创建对象obj
obj = Foo()
obj.bar()                # 执行bar方法
obj.hello("Python")  # 执行hello方法

执行方式：

面向对象：【创建对象】【通过对象执行方法】
函数编程：【执行函数】
总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

二、面向对象三大特性

面向对象的三大特性是指：封装、继承和多态。

1、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。所以，在使用面向对象的封装特性时，需要：

将内容封装到某处
从某处调用被封装的内容
**第一步：将内容封装到某处 **

# 创建类
class Foo:
    # __init__ 称为构造方法，在根据类创建对象时自动执行
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 创建类中的函数
    def hello(self):
        # do something
        print("hello %s" % self.name)
# 根据类Foo创建对象
obj1 = Foo("Python", 8)  # 将Python 和 8 分别封装到obj1(self)的name和age属性中
obj2 = Foo("Linux", 18)  # Linux 和 18 分别封装到obj1(self)的name和age属性中

第二步：从某处调用被封装的内容 调用被封装的内容时，有两种情况：

通过对象直接调用方法的属性

print(obj1.name)
print(obj1.age)

通过对象调用类的方法，再通过self调用属性

print(obj1.hello())
print(obj2.hello())

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

2、继承

面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。 例如：

猫可以：喵喵叫、吃、喝、拉、撒
狗可以：汪汪叫、吃、喝、拉、撒
猫、狗都具有（继承了）动物的基本属性吃、喝、拉、撒

# 代码实例
class Animal:
    def eat(self):
        print( "%s 吃 " % self.name)

    def drink(self):
        print( "%s 喝 " % self.name) 

    def shit(self):
        print( "%s 拉 " % self.name) 

    def pee(self):
        print( "%s 撒 " % self.name) 


class Cat(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = '猫'

    def cry(self):
        print('喵喵叫') 


class Dog(Animal):
    def __init__(self, name):
        self.name = name
        self.breed = '狗'  

    def cry(self):
        print( '汪汪叫' )  

# ######### 执行 #########
c1 = Cat('小白家的小黑猫')
c1.eat()
c2 = Cat('小黑的小白猫')
c2.drink()
d1 = Dog('胖子家的小瘦狗')
d1.eat()

所以，对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

多继承相关

新式类和经典类

当前类或者父类继承了object类，则该类为新式类，否则为经典类。

class C1:  # C1是经典类
    pass


class C2(C1):  # C2是经典类
    pass


class N1(object):  # N1是新式类
    pass
    
    
class N2(N1):  # N2是新式类
    pass

深度优先和广度优先

输入图片说明

查找方法：新式类-->广度优先，经典类-->深度优先

三、多态

多态即多种形态 Pyhon不支持多态并且也用不到多态，多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。

总结

以上就是本节对于面向对象初级知识的介绍，总结如下：

面向对象是一种编程方式，此编程方式的实现是基于对类和对象的使用
类是一个模板，模板中包装了多个“函数”供使用
对象，根据模板创建的实例（即：对象），实例用于调用被包装在类中的函数
面向对象三大特性：封装、继承和多态

来源：oschina

链接：https://my.oschina.net/u/248281/blog/782534

标签

python

面向对象

一、概述

1、 面向过程编程

2、 函数式编程

3、 面向对象编程