第5章 编程范式考察点

面向对象基础及py类常考问题

什么是面向对象编程？
Object Oriented Programming(OOP)
把对象作为基本单元, 把对象抽象成类(class) 包含成员和方法
数据封装, 继承, 多态

​ Py中使用类来实现, 过程式编程(函数), OOP(类)

Py中如何创建类?

class Person(object):   #py3 直接class Person
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def print_name(self):
        print('my name is {}'.format(self.name))

成员|方法|私有属性|魔术方法

组合与继承
优先使用组合而非继承
组合是使用其他的类实例作为自己的一个属性(Has-a 关系)

​ 子类继承父类的属性和方法(is a 关系)

​ 优先使用组合保持代码简单

​ 之前实现栈/队列使用组合

类变量和实例变量的区别
区分类变量和实例变量
类变量由所有实例共享

​ 实例变量由实例单独享有, 不同实例之间不影响

​ 当我们需要一个类的不同实例之间共享变量的时候使用类变量

class Person:

    Country = 'china'   #类变量

    def __init__(self, name):
        self.name = name #实例属性/变量

    def print_name(self):
        print(self.name)

laowang = Person('laowang')
laoli = Person('laoli')
laoli.print_name()
print(laowang.Country)
print(laoli.Country)

classmethod/staticmethod区别
都可以通过Class.method()的方式使用
classmethod第一个参数是cls, 可以引用类变量，为了使用类变量
staticmethod使用起来和普通函数一样, 只不过放在类里去组织 是代码组织的需要, 完全可放到类之外

class Person:

    Country = 'china'   #类变量

    def __init__(self, name):
        self.name = name #实例属性/变量
    @classmethod
    def print_country(cls):
        print(cls.Country)

    @staticmethod
    def join_name(first_name, last_name):
        return last_name + first_name   #last_name  

什么是元类？ 使用场景
元类(Meta Class)是创建类的类
元类允许我们控制类的生成, 比如修改类的属性等

​ 使用type来定义元类

​ 元类最常见的一个使用场景就是ORM框架

__new__     生成实例
__init__    初始化

总结
什么是面向对象？py如何使用类

​ 组合vs继承 类变量vs实例变量 classmethod vs staticmethod

​ 元类的创建和使用

py装饰器常见考题

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

编写一个记录函数耗时的装饰器

import time

def log_time(func): #接受一个函数作为参数
    def _log(*args, **kwargs):
        beg = time.time()
        res = func(*args, **kwargs)
        print('use time: {}'.format(time.time()-beg))
        return res
    return _log

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

newsleep = log_time(mysleep)
newsleep()

如何使用类编写装饰器

import time
class LogTime:

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

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

mysleep2()

如何给装饰器增加参数？
使用类装饰器比较方便实现装饰器参数

class LogTimeParams:

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

设计模式：
创建型,结构型,行为型 23种设计模式
创建型模式 py应用面试题

常见创建型设计模式

• 工厂模式(Factory)：解决对象创建问题
• 构造模式(Buider)： 控制复杂对象的创建
• 原型模式(Prototype)：通过原型的克隆创建新的实例
• 单例(Borg/Singleton): 一个类只能创建同一个对象
• 对象池模式(Pool)：预先分配同一类型的一组实例
• 惰性计算模式(Lazy Evaluation): 延迟计算(py中的property)

工厂模式
什么是工厂模式(Factory)

• 解决对象创建问题 解耦对象的创建和使用 包括工厂方法和抽象工厂

    
class DogToy:
    def speak(self):
        print("wang wang")

class CatToy:
    def speak(self):
        print("miao miao")

def toy_factory(toy_type):
    if toy_type == 'dog':
        return DogToy()
    elif toy_type == 'cat':
        return CatToy()

构造模式(Builder)：
用来控制复杂对象的承诺
创建和表示分离， 比如你要买电脑, 工厂模式直接给你需要的电脑
而构造模式允许你自己定义电脑配置, 组装完成后给你

class Computer:
    def __init__(self, serial_number):
        self.serial = serial_number
        self.memory = None      #in gigabytes
        self.hdd = None
        self.gpu = None

    def __str__(self):
        info = ('Memory: {}GB'.format(self.memory),
                'Hard Disk: {}GB'.format(self.hdd),
                'Graphics Card: {}'.format(self.gpu))
        return '\n'.join(info)

class ComputerBuilder:
    def __init__(self):
        self.computer = Computer('AG23385193')

    def configure_memory(self, amount):
        self.computer.memory = amount

    def configure_hdd(self, amount):
        self.computer.hdd = amount

    def configure_gpu(self, gpu_model):
        self.computer.gpu = gpu_model

class HardwareEngineer:
    def __init__(self):
        self.builder = None

    def construct_computer(self, memory, hdd, gpu):
        self.builder = ComputerBuilder()
        [step for step in (self.builder.configure_memory(memory),
                           self.builder.configure_hdd(hdd),
                           self.builder.configure_gpu(gpu))]

    @property
    def computer(self):
        return self.builder.computer

#use builder create 多个builder类实现不同的组装方式
engineer = HardwareEngineer()
engineer.construct_computer(hdd=500, memory=8, gpu='geForce GTX 650 Ti')
computer = engineer.computer

print(computer)

原型模式
通过克隆原型来创建新的实例
可以使用相同的原型，通过修改部分属性来创建新的示例
用途: 对于一些创建实例开销比较高的地方可以用原型模式

单例模式
实现有多种方式
单例模式：一个类创建出来的对象都是同一个
py的模块其实就是单例的，只会导入一次
使用共享同一个实例的方式来创建单例模式
#单例模式

class Singleton:
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, '_instance'):
            _instance = super().__new__(cls, *args, **kwargs)
            cls._instance = _instance
        return cls._instance

class MyClass(Singleton):
    pass

c1 = MyClass()
c2 = MyClass()

assert c1 is c2

print(id(c1))
print(id(c2))
print(c1 is c2)

设计模式：结构型模式python应用面试题

结构型模式常考题
常见结构型设计模式
装饰器模式(Decorator)：无需子类化扩展对象功能
代理模式(Proxy)：把一个对象的操作代理到另一个对象
适配器模式(Adapter)：通过一个简接层适配统一接口
外观模式(Facade)：简化复杂对象的访问问题
享元模式(Flyweight)：通过对象复用(池)改善资源利用,eg: 连接池
Model-View-Controller(MVC)：解耦展示逻辑和业务逻辑

什么是代理模式(proxy)
把一个对象的操作代理到另一个对象
之前实现的Stack/Queue, 把操作代理到deque
通常使用has-a组合关系

什么是适配器模式
把不同的对象的接口适配到同一接口
一个多功能充电头，可以给不同的电器充电, 充当了适配器
当需要给不同的对象统一接口的时候可以使用适配器模式

#适配器模式的例子
class Dog(object):
    def __init__(self):
        self.name = "Dog"

    def bark(self):
        return "woof!"

class Cat(object):
    def __init__(self):
        self.name = "Cat"

    def meow(self):
        return "meow!"

class Adapter:
    def __init__(self, obj, **adapted_methods):
        """We set adapted methods in the object's dict"""
        self.obj = obj
        self.__dict__.update(adapted_methods)

    def __getattr__(self, attr):
        """All non-adapted calls are passed to the object"""
        return getattr(self.obj, attr)

objects = []
dog = Dog()
objects.append(Adapter(dog, make_noise=dog.bark))
cat = Cat()
objects.append(Adapter(cat, make_noise=cat.meow))
for obj in objects:
    print("A {0} goes {1}".format(obj.name, obj.make_noise()))

设计模式：行为型模式Python应用面试题
行为型模式常考题
常见学习行为型设计模式
迭代器模式(Iterator)：通过统一的接口迭代对象
观察者模式(Observer)：对象发生改变的时候，观察者执行相应动作
策略模式(Strategy): 针对不同规模输入使用不同的策略
迭代器模式(Iterator)
py内置对迭代器模式的支持

''' 可以用for遍历各种Iterable的数据类型
    py可以实现_next_和_iter_实现迭代器 '''
from collections import deque

class Stack(object):    #使用组合的例子

    def __init__(self):
        self._deque = deque()   #has a deque()

    def push(self, value):
        return self._deque.append(value)

    def pop(self):
        return self._deque.pop()

    def empty(self):
        return len(self._deque) == 0

    def __iter__(self):
        res = []
        for i in self._deque:
            res.append(i)
            for i in reversed(res):
                yield i 
s = Stack()
s.push(1)
s.push(2)
for i in s:
    print(i)

观察者模式
发布订阅是一种最常用的实现方式
发布订阅用于解耦逻辑
可以通过回调等方式实现, 当发生事件时，调用相应的回调函数

#发布订阅模式

class Publisher: #发布者
    def __init__(self):
        self.observers = []     #观察者

    def add(self, observer):    #加入观察者
        if observer not in self.observers:
            self.observers.append(observer)
        else:
            print('Failed to add: {}').format(observer)

    def remove(self, observer):     #移除观察者
        try:
            self.observers.remove(observer)
        except ValueError:
            print('Failed to remove: {}').format(observer)

    def notify(self):   #调用观察者的回调
        [o.notify_by(self) for o in self.observers]

class Formatter(Publisher): #继承自发布者
    def __init__(self, name):
        super().__init__()
        self.name = name
        self._data = 0

    @property
    def data(self):
        return self._data

    @data.setter
    def data(self, new_value):
        self._data = int(new_value)
        self.notify()   #data 在合法赋值以后会执行notify

class BinaryFormatter:
    """订阅者"""

    def notify_by(self, publisher):
        print("{}: '{}' has now bin data = {}".format(
            type(self).__name__,
            publisher.name,
            bin(publisher.data))
        )

df = Formatter('formatter') #发布者
bf = BinaryFormatter()  #订阅者
df.add(bf)  #添加订阅者
df.data = 3 #设置的时候调用订阅者的notify_by

策略模式(Strategy)
1.根据不同的输入采用不同的策略
2.比如买东西超过10个打八折，超过20个打七折
3.对外暴露统一的接口，内部采用不同的策略计算

#策略模式
class Order:
    def __init__(self, price, discount_strategy=None):
        self.price = price
        self.discount_startegy = discount_strategy

    def price_after_discount(self):
        if self.discount_startegy:
            discount = self.discount_startegy(self)
        else:
            discount = 0
        return self.price - discount

    def __repr__(self):
        fmt = ""
        return fmt.format(
            self.price, self.price_after_discount()
        )

def ten_percent_discount(order):
    return order.price * 0.25 + 20

def on_sale_discount(order):
    return order.price * 0.25 + 20

def main():
    order0 = Order(100)
    order1 = Order(100, discount_strategy=ten_percent_discount)
    order2 = Order(1000, discount_strategy=on_sale_discount)
    print(order0)
    print(order1)
    print(order2)

main()

py函数式函数式编程
过程式编程，OOP， 简单函数式

py支持部分函数式编程特性
把电脑的运算视作数学上的函数计算(lambda演算)
高阶函数: map/reduce/filter
无副作用， 相同的参数调用始终产生同样的结果

map(lambda x:x*2, range(10))

list(map(lambda x:x*2, range(10)))

[i*2 for i in range(10)]
    推荐列表推导代替map
    
from functools import reduce

reduce(lambda x,y: x+y, range(1, 6))

filter(lambda x: x % 2 == 0, range(10))

[i for i range(10) if i % 2 == 0]

什么是闭包？
Closure
绑定了外部作用域的变量的函数
即使程序离开外部作用域，如果闭包仍然可见，绑定变量不会销毁
每次运行外部函数都会重新创建闭包

from functools import wraps

def cache(func): #装饰器
    store = {}  #外部变量

    @wraps(func)
    def _(n):   #闭包函数
        if n in store:
            return store[n]
        else:
            res = func(n)
            store[n] = res
            return res
    return _

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

#闭包：引用了外部自由变量的函数
#自由变量：不在当前函数定义的变量
#特性：自由变量会和闭包函数同时存在