3.python高级编程-设计模式.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2023-08-22T06:46:17.591636900Z",
     "start_time": "2023-08-22T06:46:17.576012Z"
    }
   },
   "outputs": [],
   "source": [
    "# 设计模式：封装 -> 继承 -> 多态\n",
    "# 接口：若干抽象方法的集合，对外隐藏类的内部实现提供调用。\n",
    "# SOLID原则：支持扩展（少修改代码）；接口隔离；类单一职责。\n",
    "# 创建型模式：工厂方法、抽象工厂、原型、创建者、单例。\n",
    "# 结构型模式：适配器、桥、组合、装饰、外观、享元、代理。\n",
    "# 行为型模式：解释器、责任链、命令、迭代器、中介者、备忘录、观察者、状态、策略、访问者、模板方法。\n",
    "\n",
    "from abc import ABCMeta, abstractmethod"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Can't instantiate abstract class Person with abstract methods get_name, set_name",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mTypeError\u001B[0m                                 Traceback (most recent call last)",
      "\u001B[1;32m~\\AppData\\Local\\Temp\\ipykernel_8016\\3397483004.py\u001B[0m in \u001B[0;36m<module>\u001B[1;34m\u001B[0m\n\u001B[0;32m     30\u001B[0m \u001B[0mp\u001B[0m \u001B[1;33m=\u001B[0m \u001B[0mStudent\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0;32m     31\u001B[0m \u001B[0mp\u001B[0m \u001B[1;33m=\u001B[0m \u001B[0mTeacher\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[1;32m---> 32\u001B[1;33m \u001B[0mp\u001B[0m \u001B[1;33m=\u001B[0m \u001B[0mPerson\u001B[0m\u001B[1;33m(\u001B[0m\u001B[1;33m)\u001B[0m\u001B[1;33m\u001B[0m\u001B[1;33m\u001B[0m\u001B[0m\n\u001B[0m",
      "\u001B[1;31mTypeError\u001B[0m: Can't instantiate abstract class Person with abstract methods get_name, set_name"
     ]
    }
   ],
   "source": [
    "# 1.工厂方法模式：框架、底层模块常用到。\n",
    "\n",
    "# 抽象类\n",
    "class Person(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def get_name(self): # 抽象接口，继承后需要被实现的方法接口（覆盖实现）\n",
    "        pass\n",
    "    @abstractmethod\n",
    "    def set_name(self, name): # 抽象接口，继承后需要被实现的方法接口（覆盖实现）\n",
    "        pass\n",
    "# 继承1\n",
    "class Student(Person):\n",
    "    def __init__(self):\n",
    "        self.name = None\n",
    "    def get_name(self):\n",
    "        return self.name\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "# 继承2\n",
    "class Teacher(Person):\n",
    "    def __init__(self):\n",
    "        self.name = None\n",
    "    def get_name(self):\n",
    "        return self.name\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "\n",
    "p = Student()\n",
    "p = Teacher()\n",
    "p = Person()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T06:34:26.721761300Z",
     "start_time": "2023-08-22T06:34:26.690489200Z"
    }
   },
   "id": "fad67c3d8833fbde"
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [],
   "source": [
    "# 2.简单工厂：不直接向客户端暴露对象创建的实现细节，通过工厂来创建产品类的实例。\n",
    "\n",
    "# 工厂封装创建实例对象\n",
    "class PersonFactory:\n",
    "    def create_person(self, person_type):\n",
    "        if person_type == 'student':\n",
    "            return Student()\n",
    "        elif person_type == 'teacher':\n",
    "            return Teacher()\n",
    "        else:\n",
    "            print('no such type:', person_type)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T06:28:58.347184100Z",
     "start_time": "2023-08-22T06:28:58.331533200Z"
    }
   },
   "id": "fde511f054d691f3"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# 3.抽象工厂：如各种手机品牌（苹果、华为、小米等），手机包含cpu、屏幕、电池等，每一个元件可以创建一个抽象类。（组合）"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "547da8bd503a1dbf"
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "# 4.建造者模式：一个目标类，一个建造类（通过继承来填充构建目标类的内部内容-装配过程）\n",
    "\n",
    "# 目标类\n",
    "class Person:\n",
    "    def __init__(self, name, age, gender):\n",
    "        self.name, self.age, self.gender = name, age, gender\n",
    "# 抽象建造类\n",
    "class PersonBuilder(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def set_name(self,):\n",
    "        pass\n",
    "    @abstractmethod\n",
    "    def set_age(self,):\n",
    "        pass\n",
    "    @abstractmethod\n",
    "    def set_gender(self,):\n",
    "        pass\n",
    "# 构造不同的建造类 StudentBuilder 和 TeacherBuilder\n",
    "class StudentBuilder(PersonBuilder):\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "    def set_age(self, age):\n",
    "        self.age = age\n",
    "    def set_gender(self, gender):\n",
    "        self.gender = gender\n",
    "class TeacherBuilder(PersonBuilder):\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "    def set_age(self, age):\n",
    "        self.age = age\n",
    "    def set_gender(self, gender):\n",
    "        self.gender = gender\n",
    "\n",
    "sb = StudentBuilder()\n",
    "tb = TeacherBuilder()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T06:43:48.467793800Z",
     "start_time": "2023-08-22T06:43:48.452142900Z"
    }
   },
   "id": "15431db93b987dfd"
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bin bin\n",
      "2267989522656 2267989522656\n"
     ]
    }
   ],
   "source": [
    "# 5.单例模式：只允许一个实例存在。（并行不安全，创建代码块需要加线程锁或者进程锁）。如数据库连接、日志对象。\n",
    "\n",
    "class Singleton:\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        # 并行不安全，创建代码块需要加线程锁或者进程锁\n",
    "        # 这部分内容通常固定，记住\n",
    "        if not hasattr(cls,\"_instance\"):\n",
    "            cls._instance = super(Singleton, cls).__new__(cls)\n",
    "        return cls._instance\n",
    "class MyClass(Singleton):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "mc1 = MyClass('fu')\n",
    "mc2 = MyClass('bin') # 单例内容已被修改\n",
    "print(mc1.name, mc2.name)\n",
    "print(id(mc1), id(mc2))"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T06:55:10.374182300Z",
     "start_time": "2023-08-22T06:55:10.358559500Z"
    }
   },
   "id": "7ff8cac7d758d12c"
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "# 6.适配器模式：将一个接口转换为客户希望的另一个接口，使其兼容。（类似变压器、转换接口）\n",
    "# 类适配器 和 对象适配器\n",
    "\n",
    "# 抽象类\n",
    "class Person(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def get_name(self): # 抽象接口，继承后需要被实现的方法接口（覆盖实现）\n",
    "        pass\n",
    "    @abstractmethod\n",
    "    def set_name(self, name): # 抽象接口，继承后需要被实现的方法接口（覆盖实现）\n",
    "        pass\n",
    "# 继承1\n",
    "class Student(Person):\n",
    "    def __init__(self):\n",
    "        self.name = None\n",
    "    def get_name(self):\n",
    "        return self.name\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "# 继承2\n",
    "class Teacher(Person):\n",
    "    def __init__(self):\n",
    "        self.name = None\n",
    "    def get_name(self):\n",
    "        return self.name\n",
    "    def set_name(self, name):\n",
    "        self.name = name\n",
    "# 需要适配的类\n",
    "class Parent:\n",
    "    # 要将接口转化为统一的set_name，实际更复杂\n",
    "    def setting_name(self, name):\n",
    "        self.name = name\n",
    "    # 要将接口转化为统一的get_name，实际更复杂\n",
    "    def gettting_name(self):\n",
    "        return self.name\n",
    "# 解决办法一：类适配器（继承双方类实现）\n",
    "class NewParent(Person, Parent):\n",
    "    def set_name(self, name):\n",
    "        self.setting_name(name)\n",
    "    def get_name(self):\n",
    "        return self.gettting_name()\n",
    "# 解决办法二：对象适配器（继承主类，目标类对象作为一个属性）\n",
    "class ParentAdapter(Person):\n",
    "    def __init__(self, parent):\n",
    "        self.parent = parent\n",
    "    def set_name(self, name):\n",
    "        self.parent.setting_name(name)\n",
    "    def get_name(self):\n",
    "        return self.parent.gettting_name()\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T07:07:50.163983Z",
     "start_time": "2023-08-22T07:07:50.132708Z"
    }
   },
   "id": "ee2f822942b01501"
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [],
   "source": [
    "# 7.桥模式：将一个事物的两个维度分离，使其对立的变化。如形状和颜色的扩展。\n",
    "\n",
    "class Shape(metaclass=ABCMeta):\n",
    "    def __init__(self, color): # 桥\n",
    "        self.color = color\n",
    "    @abstractmethod\n",
    "    def draw(self):\n",
    "        pass\n",
    "class Color(metaclass=ABCMeta):\n",
    "    def __init__(self, shape): # 桥\n",
    "        self.shape = shape\n",
    "    @abstractmethod\n",
    "    def paint(self):\n",
    "        pass"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T07:31:50.529414100Z",
     "start_time": "2023-08-22T07:31:50.513789700Z"
    }
   },
   "id": "20c62423eeb8f4c0"
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "draw a point: 0 0\n",
      "draw a circle: centroid= 0 radius= 1\n",
      "start draw a complex picture:\n",
      "draw a point: 0 0\n",
      "draw a circle: centroid= 0 radius= 1\n"
     ]
    }
   ],
   "source": [
    "# 8.组合模式：部分与整体的层次结构，简单对象-复杂对象。\n",
    "\n",
    "# 抽象类\n",
    "class Graph(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def draw(self):\n",
    "        pass\n",
    "# 简单继承1：点\n",
    "class Point(Graph):\n",
    "    def __init__(self, x, y):\n",
    "        self.x, self.y = x, y\n",
    "    def draw(self):\n",
    "        print('draw a point:', self.x, self.y)\n",
    "# 简单继承2：圆\n",
    "class Circle(Graph):\n",
    "    def __init__(self, c, r):\n",
    "        self.c, self.r = c, r\n",
    "    def draw(self):\n",
    "        print('draw a circle:', 'centroid=', self.c, 'radius=', self.r)\n",
    "# 复杂构件：图像\n",
    "class Picture(Graph):\n",
    "    def __init__(self,):\n",
    "        self.children = []\n",
    "    def add(self, graph):\n",
    "        self.children.append(graph)\n",
    "    def draw(self):\n",
    "        print('start draw a complex picture:')\n",
    "        for graph in self.children: # 组合：各自画图\n",
    "            graph.draw()\n",
    "\n",
    "p = Point(0,0)\n",
    "p.draw()\n",
    "c = Circle(0,1)\n",
    "c.draw()\n",
    "\n",
    "picture = Picture()\n",
    "picture.add(p)\n",
    "picture.add(c)\n",
    "picture.draw()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T07:41:40.574453900Z",
     "start_time": "2023-08-22T07:41:40.558852800Z"
    }
   },
   "id": "bb131240d613cc7f"
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start cpu...\n",
      "start memory...\n",
      "start screen...\n",
      "end cpu...\n",
      "end memory...\n",
      "end screen...\n"
     ]
    }
   ],
   "source": [
    "# 9.外观模式：定义一个高层接口，为子系统中一组接口提供一致的界面。提高灵活性和安全性。\n",
    "\n",
    "# 例如电脑包含cpu、硬盘和屏幕，不让用户直接调用访问，只需要知道调用电脑\n",
    "class CPU:\n",
    "    def start(self):\n",
    "        print('start cpu...')\n",
    "    def stop(self):\n",
    "        print('end cpu...')\n",
    "class Memory:\n",
    "    def start(self):\n",
    "        print('start memory...')\n",
    "    def stop(self):\n",
    "        print('end memory...')\n",
    "class Screen:\n",
    "    def start(self):\n",
    "        print('start screen...')\n",
    "    def stop(self):\n",
    "        print('end screen...')\n",
    "class Computer:\n",
    "    def __init__(self):\n",
    "        self.cpu, self.memory, self.screen = CPU(), Memory(), Screen()\n",
    "    def start(self):\n",
    "        self.cpu.start()\n",
    "        self.memory.start()\n",
    "        self.screen.start()\n",
    "    def stop(self):\n",
    "        self.cpu.stop()\n",
    "        self.memory.stop()\n",
    "        self.screen.stop()\n",
    "\n",
    "c = Computer()\n",
    "c.start()\n",
    "c.stop()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T07:49:44.951194800Z",
     "start_time": "2023-08-22T07:49:44.888698800Z"
    }
   },
   "id": "b94918968fe18649"
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "outputs": [],
   "source": [
    "# 10.代理模式：为其他对象提供一种代理以控制对这个对象的访问。远程代理、虚拟代理、保护代理。\n",
    "\n",
    "# 文件访问代理：用户只能使用特定的端口\n",
    "class FileProxy:\n",
    "    def __init__(self, fpath):\n",
    "        self.fpath = fpath\n",
    "        self.content = open(fpath,'r').read()\n",
    "    def get_content(self): # 1\n",
    "        if self.content is None:\n",
    "            self.content = open(self.fpath,'r').read()\n",
    "        return self.content\n",
    "    def set_content(self, content): # 2\n",
    "        open(self.fpath, 'w').write(content)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T08:01:18.968551200Z",
     "start_time": "2023-08-22T08:01:18.921680200Z"
    }
   },
   "id": "51816ad10eb1fa20"
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CEOManager：旷工过长，开除！\n"
     ]
    }
   ],
   "source": [
    "# 11.责任链模式：有多个对象有机会处理，避免发送者和接收者之间的耦合关系。将这些对象连成一条链，传递该请求，制导有一个对象处理它为止。\n",
    "# 降低耦合：不用知道到底哪个层级处理，责任链传递就行。pipeline。\n",
    "\n",
    "# 请假 -> 项目主管(1天内) -> 部门经理(5天的权限可以) -> 总经理（10天以上开除）\n",
    "# 链表结构\n",
    "\n",
    "class Handler(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def handle_leave(self, num_days):\n",
    "        pass\n",
    "class ProjectManager(Handler):\n",
    "    def __init__(self, next):\n",
    "        self.next = next\n",
    "    def handle_leave(self, num_days):\n",
    "        if num_days<=1:\n",
    "            print('ProjectManager：批准！')\n",
    "        else:\n",
    "            self.next.handle_leave(num_days)\n",
    "class DepartmentManager(Handler):\n",
    "    def __init__(self, next):\n",
    "        self.next = next\n",
    "    def handle_leave(self, num_days):\n",
    "        if num_days<=5:\n",
    "            print('DepartmentManager：批准！')\n",
    "        else:\n",
    "            self.next.handle_leave(num_days)\n",
    "class CEOManager(Handler):\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    def handle_leave(self, num_days):\n",
    "        if num_days<=10:\n",
    "            print('CEOManager：批准！')\n",
    "        else:\n",
    "            print('CEOManager：旷工过长，开除！')\n",
    "# 责任链： pm -> dm -> ceom\n",
    "ceom = CEOManager()\n",
    "dm = DepartmentManager(ceom)\n",
    "pm = ProjectManager(dm)\n",
    "\n",
    "pm.handle_leave(11)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T08:17:11.356244800Z",
     "start_time": "2023-08-22T08:17:11.340617200Z"
    }
   },
   "id": "8548fbd787133d46"
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starff: fu receive message: 公司解散！\n",
      "starff: bin receive message: 公司解散！\n"
     ]
    }
   ],
   "source": [
    "# 12.观察者模式：一种一对多的依赖关系，当一个对象发生变化时，所有依赖于它的对象都得到通知并自动更新。又称为“发布-订阅”模式。广播推送。\n",
    "\n",
    "# 观察者（订阅者）：抽象\n",
    "class Observer(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def update(self ,notice):\n",
    "        pass\n",
    "# 发布者\n",
    "class Notice:\n",
    "    def __init__(self):\n",
    "        self.observers = [] # 观察者列表\n",
    "    def add(self, observer):\n",
    "        self.observers.append(observer)\n",
    "    def remove(self, observer):\n",
    "        self.observers.remove(observer)\n",
    "    def notify(self): # 推送\n",
    "        for observer in self.observers:\n",
    "            observer.update(self)\n",
    "class StaffNotice(Notice):\n",
    "    def __init__(self, company_notice_content):\n",
    "        super().__init__()\n",
    "        self.__company_notice_content  = company_notice_content\n",
    "    @property\n",
    "    def company_notice_content(self): # property\n",
    "        return self.__company_notice_content\n",
    "    @company_notice_content.setter\n",
    "    def company_notice_content(self, content):\n",
    "        self.__company_notice_content = content\n",
    "class Staff(Observer):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.company_notice_content = None\n",
    "    def update(self ,notice):\n",
    "        self.company_notice_content = notice.company_notice_content\n",
    "        print('starff:', self.name, 'receive message:', self.company_notice_content)\n",
    "\n",
    "sn = StaffNotice('公司解散！')\n",
    "s1, s2 = Staff('fu'), Staff('bin')\n",
    "sn.add(s1)\n",
    "sn.add(s2)\n",
    "sn.notify()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T08:39:37.918734900Z",
     "start_time": "2023-08-22T08:39:37.849600900Z"
    }
   },
   "id": "73e2361d992734d9"
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "执行快策略！\n"
     ]
    }
   ],
   "source": [
    "# 13.策略模式：定义一系列算法并将其封装起来，使其相互可替换。独立于客户变化，根据上下文切换算法。\n",
    "# 如闲时策略和忙时策略\n",
    "\n",
    "class Strategy(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def excute(self, data):\n",
    "        pass\n",
    "class FastStrategy(Strategy):\n",
    "    def __init__(self, *args):\n",
    "        self.args = args\n",
    "    def excute(self, data):\n",
    "        print('执行快策略！')\n",
    "class SlowStrategy(Strategy):\n",
    "    def __init__(self, *args):\n",
    "        self.args = args\n",
    "    def excute(self, data):\n",
    "        print('执行慢策略！')\n",
    "class Context:\n",
    "    def __init__(self):\n",
    "        self.strategy = None\n",
    "    def auto_excute_strategy(self, fast_flag): # 根据上下文来选择合适的策略并执行\n",
    "        if fast_flag:\n",
    "            self.strategy = FastStrategy()\n",
    "        else:\n",
    "            self.strategy = SlowStrategy()\n",
    "        self.strategy.excute('111')\n",
    "c = Context()\n",
    "c.auto_excute_strategy(True)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T09:02:13.380421600Z",
     "start_time": "2023-08-22T09:02:13.317921900Z"
    }
   },
   "id": "e21aa0543cc416a7"
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start a server thread...\n",
      "run a server thread...\n",
      "start a client thread...\n",
      "run a client thread...\n"
     ]
    }
   ],
   "source": [
    "# 14.模板方法模式：定义一个算法的骨架，将一些步骤延迟到子类中实现。子类不改变算法内部结构可重定义该算法的内容步骤。\n",
    "# 这个设计模式很常见。\n",
    "\n",
    "class Thread(metaclass=ABCMeta):\n",
    "    @abstractmethod\n",
    "    def start(self):\n",
    "        pass\n",
    "    @abstractmethod\n",
    "    def run(self):\n",
    "        pass\n",
    "class ServerThread(Thread):\n",
    "    def start(self):\n",
    "        print('start a server thread...')\n",
    "    def run(self):\n",
    "        print('run a server thread...')\n",
    "class ClientThread(Thread):\n",
    "    def start(self):\n",
    "        print('start a client thread...')\n",
    "    def run(self):\n",
    "        print('run a client thread...')\n",
    "\n",
    "st = ServerThread()\n",
    "st.start()\n",
    "st.run()\n",
    "ct = ClientThread()\n",
    "ct.start()\n",
    "ct.run()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-08-22T09:11:30.306085300Z",
     "start_time": "2023-08-22T09:11:30.212334700Z"
    }
   },
   "id": "faab468e592468c1"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   },
   "id": "a2c9e9e778de077f"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}