<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[陈所长]]></title><description><![CDATA[]]></description><link>https://blog.csdn.net/u012205706</link><language>zh-cn</language><generator>https://blog.csdn.net/</generator><copyright><![CDATA[Copyright &copy; u012205706]]></copyright><item><title><![CDATA[allure参数配置生成]]></title><link>https://blog.csdn.net/u012205706/article/details/114267504</link><guid>https://blog.csdn.net/u012205706/article/details/114267504</guid><author>u012205706</author><pubDate>Mon, 01 Mar 2021 17:24:13 +0800</pubDate><description><![CDATA[使用pytest+allure生成报告的命令配置：

cd /d D:\v5_env_ui\Scripts &amp;&amp; activate &amp;&amp; cd /d D:\v5-auto\workspace\ltlv5\ui-main\ltlv5uicase &amp;&amp; pytest --tb=no --alluredir=../allure-results




]]></description><category></category></item><item><title><![CDATA[urllib3.exceptions.MaxRetryError问题的解决]]></title><link>https://blog.csdn.net/u012205706/article/details/111982545</link><guid>https://blog.csdn.net/u012205706/article/details/111982545</guid><author>u012205706</author><pubDate>Wed, 30 Dec 2020 14:47:40 +0800</pubDate><description><![CDATA[1.背景描述

在使用python+selenium做UI自动化时，单个脚本执行通过，多个脚本执行时，执行到第二个时失败。测试代码如下：


# !/usr/bin/env python
# -*- coding: utf-8 -*-
from ltlv5uidata.init import autobench


class TestGetCode:
    def setup(self):
        self.ui = autobench.ui
        self.ui.login_page]]></description><category></category></item><item><title><![CDATA[0.关于设计模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111818341</link><guid>https://blog.csdn.net/u012205706/article/details/111818341</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 16:41:52 +0800</pubDate><description><![CDATA[1.关于设计模式

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。

设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。

这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。

即：

设计模式是解决软件开发的常见方法经验，这些方法经验是从众多的实验、错误中总结得到的。

2.设计模式的分类



书籍推荐：《实战python设计模式》

当然，你也可以阅读这些博客，作为你学习设计的模式的预备课程。例子都是使用py]]></description><category></category></item><item><title><![CDATA[15.模板方法模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111814231</link><guid>https://blog.csdn.net/u012205706/article/details/111814231</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 16:06:25 +0800</pubDate><description><![CDATA[1.定义

（1）内容

定义一个操作中的算法骨架，将一些步骤延迟到子类中。

模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

（2）使用模板方法，需要用到两种角色

抽象类：抽象类的作用是是定义抽象类（钩子操作），实现一个模板方法作为算法的骨架。

具体类：具体类的作用实现原子操作。

2.实现


from abc import ABCMeta, abstractmethod
from time import sleep

# 抽象类
class Window(metacla]]></description><category></category></item><item><title><![CDATA[14.策略模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111812610</link><guid>https://blog.csdn.net/u012205706/article/details/111812610</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 15:54:48 +0800</pubDate><description><![CDATA[1.定义

定义一个个策略，把它们封装起来，并且使它们可以相互替换。

本模式使得算法可独立于使用它的客户而变化。

角色：

抽象策略

具体策略

上下文

2.实现


from abc import abstractmethod, ABCMeta
from datetime import datetime

# 抽象策略
class Strategy(metaclass=ABCMeta):
    @abstractmethod
    def execute(self, data):
     .]]></description><category></category></item><item><title><![CDATA[13.观察者模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111807541</link><guid>https://blog.csdn.net/u012205706/article/details/111807541</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 15:41:43 +0800</pubDate><description><![CDATA[1.定义

观察者模式应用比较广泛，又被称为“发布-订阅”模式。

它用来定义对象间一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都得到通知并被自动更新。

观察者模式的角色有：

抽象主题

具体主题（发布者）

抽象观察者

具体观察者（订阅者）



一个主题存在一个或多个订阅者，一个订阅者可订阅多个主题，类似于微信公众号的订阅。

具体主题在发布消息时，还要把消息推送到具体的订阅者处。

订阅者具有订阅某个主题消息（绑定 attach）、不订阅某个消息（不绑定 detach）方法]]></description><category></category></item><item><title><![CDATA[12.责任链模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111802438</link><guid>https://blog.csdn.net/u012205706/article/details/111802438</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 15:03:27 +0800</pubDate><description><![CDATA[1.定义

（1）责任链模式的内容：

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。

将这些对象连成一条链并沿着这条链传递该请求，直到有一个对象处理它为止。

责任链的角色：

（2）抽象处理者

具体处理者

客户端

如图所示：



1级处理、2级处理、n级处理 构成了处理的链路，每个级别的处理对象都具有一定的处理权限机会。

或每个级别的处理对象都进行处理，或只有满足当前处理对象的要求才可进行处理。

高层代码只需要将数据传递给 1级处理对象 即可，而不用去管后面谁去进]]></description><category></category></item><item><title><![CDATA[11.代理模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111799141</link><guid>https://blog.csdn.net/u012205706/article/details/111799141</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 14:41:57 +0800</pubDate><description><![CDATA[1.定义

为其它对象提供一种代理以控制对这个对象的访问。

（1）角色：

抽象实体

实体

代理

（2）应用场景：

远程代理：为远程的对象提供代理（通过ORM向数据库写值，不用关注数据库是在远程）

虚代理：根据需要创建很大的对象（需要的时候创建对象）

保护代理：控制对原始对象的访问，用于对象有不同的访问权限。

2.实现

（1）不使用代理模式


from abc import ABCMeta, abstractmethod

class Subject(metaclass=ABCMeta)]]></description><category></category></item><item><title><![CDATA[10.外观模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111794610</link><guid>https://blog.csdn.net/u012205706/article/details/111794610</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 14:06:10 +0800</pubDate><description><![CDATA[1.定义

外观模式为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层的接口，这个接口使得这一子系统更加容易使用。

外观模式下的角色有外观和子系统类。

优点：

减少系统相互依赖，提高灵活性，提高了安全性。

如图所示：



系统内部存在method1...methodn方法，每个方法有各自处理逻辑，methodAll调用n个方法，向高层client提供一个统一的入口，供调用。

而client无需知道method1...methodn的调用方法，只需要知道methodAll 的调用方法即]]></description><category></category></item><item><title><![CDATA[9.组合模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111790888</link><guid>https://blog.csdn.net/u012205706/article/details/111790888</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 13:49:08 +0800</pubDate><description><![CDATA[1.定义

将对象组合成树形结构以表示“部分-整体”的层次结构(特别是结构是递归的)。

组合模式使得用户对单个对象和组合对象的使用具有一致性。

优点：

定义了包含基本对象和组合对象的层次结构；

简化客户端代码，客户端可以一致地使用组合对象和单个对象；

更加容易增加新类型的组件。

举例：



单个形状可成组，得到：



对大哥形状可以进行放大、缩小、变换颜色、样式等，而对成组形状也可进行放大、缩小、变换颜色、样式等。对单个形状和组合形状的操作具有一致性。

2.实现


from abc im]]></description><category></category></item><item><title><![CDATA[8.桥模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111774513</link><guid>https://blog.csdn.net/u012205706/article/details/111774513</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 12:04:30 +0800</pubDate><description><![CDATA[1.定义

桥模式是将一个事物的两个维度分离，使其都可以独立地变化。

当事物有两个维度的表现，两个维度都可能扩展时使用。

2.实现

设定实现图形绘制类的一套接口，共有两个维度的属性：形状、颜色，并且两者都可以扩展。以下有两种实现方式：

（1）不使用桥模式


class Shape:
	pass

class Rectangle(Shape):
	pass

class Circle(Shape):
	pass

class RedRectangle(Rectangle):
	pass

clas.]]></description><category></category></item><item><title><![CDATA[7.适配器模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111773739</link><guid>https://blog.csdn.net/u012205706/article/details/111773739</guid><author>u012205706</author><pubDate>Sun, 27 Dec 2020 11:38:31 +0800</pubDate><description><![CDATA[1.定义

将一个类的接口转换成客户希望的另外一个接口，适配器使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

实现适配器的两种方式，类适配器使用多继承，对象适配器使用组合。组合就是一个类中放入另一类的对象。

2.分类

（1）类适配器模式


from abc import ABCMeta, abstractmethod

# 目标接口
class Payment(object, metaclass=ABCMeta):
    @abstractmethod
    def pay(sel.]]></description><category></category></item><item><title><![CDATA[你真的会学习吗？从结构化思维说起]]></title><link>https://blog.csdn.net/u012205706/article/details/111660921</link><guid>https://blog.csdn.net/u012205706/article/details/111660921</guid><author>u012205706</author><pubDate>Fri, 25 Dec 2020 09:30:03 +0800</pubDate><description><![CDATA[【转自阿里技术】

一 前言

试想，接手一个新的业务方向，业务方的诉求是要求你能快速熟悉并投入，你会如何去应对这样的挑战呢？再试想，作为一名风控技术的新人，你需要在原先的防控策略上引入新的图计算技术，又该如何快速学习新的技术，从而达成业务目标？

如何你恰好听说过XY问题的理论，你就会知道，上述问题其实都是笔者抛出来的Y问题，X问题是我们到底应该如何快速去学习一项新的课题。




XY问题是他人询问自己的尝试的解决方案Y，而不是实际问题X。这会浪费大量的时间和精力，无论是寻求帮助的人，还是那些提供帮..]]></description><category></category></item><item><title><![CDATA[python操作kafka报错：return ‘＜SimpleProducer batch=%s＞‘ % self.async]]></title><link>https://blog.csdn.net/u012205706/article/details/111504762</link><guid>https://blog.csdn.net/u012205706/article/details/111504762</guid><author>u012205706</author><pubDate>Tue, 22 Dec 2020 09:13:15 +0800</pubDate><description><![CDATA[1.遇到的问题

C:\ProgramData\Anaconda3\python.exe C:/git/base_function/kafka_usage.py
Traceback (most recent call last):
  File "C:/git/base_function/kafka_usage.py", line 6, in &lt;module&gt;
    from kafka import KafkaProducer
  File "C:\ProgramData\Anaconda.]]></description><category></category></item><item><title><![CDATA[6.单例模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111432623</link><guid>https://blog.csdn.net/u012205706/article/details/111432623</guid><author>u012205706</author><pubDate>Sun, 20 Dec 2020 15:46:19 +0800</pubDate><description><![CDATA[1.定义

单例模式保证一个类只有一个实例，并提供一个访问它的全局访问点。

2.角色

使用__new__方法实现


class Singleton:
    # 当类实例化时，首先会调用类的__new__方法进行初始化，产生一个新的对象
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            # 调用python的__new__方法进行初始化
            cls]]></description><category></category></item><item><title><![CDATA[5.建造者模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111430486</link><guid>https://blog.csdn.net/u012205706/article/details/111430486</guid><author>u012205706</author><pubDate>Sun, 20 Dec 2020 15:27:14 +0800</pubDate><description><![CDATA[1.定义

建造者模式是将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

2.角色

抽象创建者

具体创建者

指挥者

产品


from abc import ABCMeta, abstractmethod

# ------产品------
class Player:
    def __init__(self, face=None, body=None, arms=None, legs=None):
        self.face = face
        s.]]></description><category></category></item><item><title><![CDATA[4.抽象工厂模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111426695</link><guid>https://blog.csdn.net/u012205706/article/details/111426695</guid><author>u012205706</author><pubDate>Sun, 20 Dec 2020 15:14:43 +0800</pubDate><description><![CDATA[1.定义

定义一个工厂类的接口让工厂子类来创建一系列相关或者相互依赖的对象。相比工厂方法模式，抽象工厂模式中的每一个具体工厂都生产一套产品。

2.角色

抽象的产品

具体的产品

抽象的工厂

具体的工厂

客户端


from abc import ABCMeta, abstractmethod


# ------抽象的产品------
class PhoneShell(metaclass=ABCMeta):
    @abstractmethod
    def show_shell(self)]]></description><category></category></item><item><title><![CDATA[3.工厂方法模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111421823</link><guid>https://blog.csdn.net/u012205706/article/details/111421823</guid><author>u012205706</author><pubDate>Sun, 20 Dec 2020 14:55:16 +0800</pubDate><description><![CDATA[1.定义

每个具体产品对应一个具体的工厂类，工厂类中包含生产该产品的全套方法。

2.具体角色

抽象产品角色

具体产品角色

抽象工厂角色

具体工厂角色


from abc import ABCMeta, abstractclassmethod, abstractmethod

class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self, money):
        pass

# 具体产品角色
class Al]]></description><category></category></item><item><title><![CDATA[2.简单工厂模式]]></title><link>https://blog.csdn.net/u012205706/article/details/111416017</link><guid>https://blog.csdn.net/u012205706/article/details/111416017</guid><author>u012205706</author><pubDate>Sun, 20 Dec 2020 13:22:20 +0800</pubDate><description><![CDATA[1.定义

简单工厂模式不属于23设计模式中的一种。

简单工厂模式通过不向客户端暴露具体对象的创建模式，而是通过一个工厂类来负责产品类实例的创建。

2.简单工厂模式的角色有

工厂角色：定义工厂中的具体方法和变量。如：Alipayment。

抽象产品角色：用来将工厂角色中的类实例化出具体对象的类。

具体产品角色：由抽象产品角色实例化出具体对象，具体对象可以控制实例出不同的工厂对象，通过工厂对象可以调用工厂的中方法和属性。


from abc import ABCMeta, abstractclas]]></description><category></category></item><item><title><![CDATA[1.面向对象设计的5大原则]]></title><link>https://blog.csdn.net/u012205706/article/details/111415619</link><guid>https://blog.csdn.net/u012205706/article/details/111415619</guid><author>u012205706</author><pubDate>Sun, 20 Dec 2020 12:55:31 +0800</pubDate><description><![CDATA[1.开放封闭原则

定义：

一个软件实体如模块，类，函数应该对扩展开放，对修改关闭。即软件实体应该在不修改源码的情况下进行修改。

理解：

面向对象软件开发过程中，存在类的封装，类实例化出对象，对象调用类中方法和属性。

一个类可以实例出多个对象，类中方法、属性被多个对象和引用，因此一般不要修改类中已存在的方法，而是应该在不影响其原有的功能上，去修改其功能。



2.里斯替换原则

定义：所有引用父类的地方必须能透明地使用其子类的对象，一个简单的例子加强理解

理解：User类中和VIPUSer类中都]]></description><category></category></item></channel></rss>