编程范式总结

什么是面向对象编程?

Object Oriented Programming(OOP)

​ 把对象作为基本单元，把对象抽象成类(Class)，包含成员和方法
​ 数据封装、继承、多态
​ Python中使用类来实现。过程式编程(函数)，OOP(类)

类变量和实例变量的区别

区分类变量和实例变量

​ 类变量由所有实例共享
​ 实例变量由实例单独享有，不同实例之间不影响
​ 当我们需要在一个类的不同实例之间共享变量的时候使用类变量

classmethod/staticmethod区别

classmethod vs staticmethod

​ 都可以通过Class.method()的方式使用
​ classmethod第一个参数是cls，可以引用类变量
​ staticmethod使用起来和普通函数一样，只不过放在类里去组织

什么是元类?使用场景

元类(Meta Class)是创建类的类

​ 元类允许我们控制类的生成，比如修改类的属性等
​ 使用type来定义元类
​ 元类最常见的一个使用场景就是ORM框架

什么是装饰器

Decorator

​ Python中一切皆对象，函数也可以当做参数传递
​ 装饰器是接受函数作为参数，添加功能后返回一个新函数的函数(类)
​ Python中通过@使用装饰器

import time


def log_time(func):
    def _log(*args, **kargs):
        beg = time.time()
        res = func(*args, **kargs)
        print('use time:{}'.format(time.time() - beg))
        return res

    return _log


@log_time  # @装饰器语法糖
def mysleep():
    time.sleep(1)


if __name__ == '__main__':
    mysleep()
    # 去除@log_time
    # newsleep = log_time(mysleep)
    # newsleep()

import time


class LogTime():
    def __call__(self, func):
        def _log(*args, **kargs):
            beg = time.time()
            res = func(*args, **kargs)
            print('use time:{}'.format(time.time() - beg))
            return res

        return _log


@LogTime()
def mysleep():
    time.sleep(1)


if __name__ == '__main__':
    mysleep()

import time


class LogTime():
    def __init__(self, use_int=False):
        self.use_int = use_int

    def __call__(self, func):
        def _log(*args, **kargs):
            beg = time.time()
            res = func(*args, **kargs)
            if self.use_int:
                print('use time:{}'.format(int(time.time() - beg)))
            else:
                print('use time:{}'.format(time.time() - beg))
            return res

        return _log


@LogTime(use_int=True)
def mysleep():
    time.sleep(1)


if __name__ == '__main__':
    mysleep()

设计模式

查看设计模式总结文章

函数式编程

Python支持部分函数式编程特性

​ 把电脑的运算视作数学上的函数计算(lambda演算)
​ 高阶函数: map/reduce/filter
​ 无副作用，相同的参数调用始终产生同样的结果

什么是闭包?

Closure

​ 绑定了外部作用域的变量的函数
​ 即使程序离开外部作用域，如果闭包仍然可见，绑定变量不会销毁
​ 每次运行外部函数都会重新创建闭包
​ 闭包:引用了外部自由变量的函数
​ 自由变量:不在当前函数定义的变量
​ 特性:自由变量会和闭包函数同时存在

from functools import wraps


def cache(func):
    store = {}

    @wraps(func)
    def _(n):
        if n in store:
            print(store[n])
            return store[n]
        else:
            res = func(n)
            store[n] = res
            return res
	
    return _


@cache
def f(n):  # 斐波那契数列
    if n == 0:
        return 0
    if n == 1:
        return 1
    return f(n - 1) + f(n - 2)


if __name__ == '__main__':
    print(f(7))