面向对象知识点

面向过程编程
    一、解释
    面向过程：核心是过程二字，过程即解决问题的步骤，基于面向过程去设计程序就像是在设计，流水线式的编程思想，
    在设计程序时，需要把整个流程设计出来，一条工业流水线，是一种机械式的思维方式。

    二、优缺点
    优点：程序体系结构清晰，可以把复杂的问题简单化，流程化。
    缺点：可扩展性差，一条流线只是用来解决一个问题，所以说面向过程的应用多为不需要经常变化的软件。
    应用场景：linux内核， git, httpd, shell脚本 

    三、实例(利用程序函数进行面向过程编程)
    过滤一个文件下的子文件、字文件夹的内容中的相应的内容，在linux中的命令就是grep -rl 'python' /etc
    使用了python的包os里面的walk(),能够把参数中的路径下的文件夹打开并返回一个元组

    >>> import os
    >>> os.walk('D:	est')        
    generator object walk at 0x0000000002ADB3B8

    >>> os.walk('D:\test')        # 以后使用这种路径方式，win下
    >>> os.walk(r'D:	est')       # 使用r 是让字符串中的符号没有特殊意义，针对的是转义
    出现错误，是因为路径的原因，但是在不同的机器上有的是可以的

    >>> g=os.walk('D:	est')
    >>> next(g)
    Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    StopIteration
    以后推荐是用

    >>> g=os.walk('D:\test')
    >>> next(g)
    ('D:\test', ['a', 'b'], ['test.txt'])
    返回的是一个元组，第一个元素是文件的路径，第二个是文件夹，第三个是该路径下的文件

    1.2.1 程序流程
        找文件路径 --os.walk
        然后打开文件 --open
        读取文件的每一行内容 -- for line in f
        过滤一行内容中是否有Python if 'python' in line
        打印包含Python的文件路径
    程序是从上往下执行的，1产生的路径作为参数给2,2产生的给3...

    实例请看：https://www.cnblogs.com/rendawei/p/7051145.html 博客

面向对象编程

    概述：
        对函数进行分类和封装，让开发“更快更好更强...”
        面向对象编程是一种编程方式，此编程方式的落地需要使用“类”和“对象”来实现，所以，面向对象编程其实就是对
        “类”和“对象”的使用。
        类就是一个模板，模板里可以包含多个函数，函数里实现一些功能
        对象则是根据模板创建的实例，通过实例对象可以执行类中的函数。
            1.class是关键字，表示类
            2.创建对象，类名称后加括号即可
        PS：类中的函数第一个参数必须是self(详细见：类的三大特性之封装)
        类中定义的函数叫做“方法”

        # 创建类
        class Foo:
            def Bar(self):
                print 'Bar'

            def Hello(self, name):
                print('i am %s' %name)

        #根据Foo创建对象obj
        obj = Foo()
        obj.Bar()               #执行Bar方法
        obj.Hello('wupeiqi')    #执行Hello方法

        面向对象：[创建对象] [通过对象执行方法]
        函数编程：[执行函数]
        观察上述对比答案则是肯定的，然后并非绝对，场景的不同适合其的编程方式也不同。
        总结：函数式的应用场景 --> 各个函数之间是独立且无共用的数据

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

        一、封装
            封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
            所以，在使用面向对象的封装特性时，需要：
                1.将内容封装到某处
                2.从某处调用被封装的内容
            
            # 封装实例
                # 第一步：将内容封装到某处

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

                # 根据Foo创建对象
                # 自动执行Foo类的 __init__ 方法
                obj1 = Foo('changhao', 20)  #将changhao和20分别封装到 obj2 self的name和age属性中

                # 根据类Foo创建对象
                # 自动执行Foo类的 __init__ 方法
                obj2 = Foo('changhao2', 22)  #将changhao2和22分别封装到 obj2 self的name和age属性中

                self是一个形式参数，当执行obj1=Foo('changhao',20)时，self等于obj1
                当执行obj2 = Foo('changhao2',22)时,self等于obj2

                所以，内容其实被封装到了对象obj1和obj2中，每个对象中都有name和age属性，在内存里类似于下图来保存。

                参考此博客http://www.cnblogs.com/wupeiqi/p/4493506.html
定义类与实例化

属性查找与绑定方法

面向对象扩展性总结

继承与重用性

派生

继承的实现原理

在子类中重用父类的方法或属性

组合

抽象类与归一化

多态与多态性

封装
    隐藏属性

    封装意义

    封装于扩展性

property的使用

绑定方法与非绑定方法
    介绍
    使用

反射

内置方法介绍

元类介绍

自定义元类控制类
    创建
    实例化行为
    实例化行为的应用

什么是异常处理

try..except...详细用法