精华内容
下载资源
问答
  • Python去除列表中的重复元素

    万次阅读 多人点赞 2019-04-30 23:21:39
    Python去除列表中的重复元素:三种方法 1.使用set去除重复元素 list1 = [1, 2, 5, 6, 7, 4, 8, 2, 7, 9, 4, 6, 3] list2 = list(set(list1)) print(list2) 输出结果如下: 会改变原列表元素的顺序。 [1, 2, 3, 4, 5...

    Python去除列表中的重复元素:三种方法

    1.使用set去除重复元素

    list1 = [1, 2, 5, 6, 7, 4, 8, 2, 7, 9, 4, 6, 3]
    list2 = list(set(list1))
    print(list2)
    

    输出结果如下:
    会改变原列表元素的顺序。

    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    

    2.for循环语句

    list1 = [1, 2, 5, 6, 7, 4, 8, 2, 7, 9, 4, 6, 3]
    list2 = []
    for i in list1:
        if not i in list2:
            list2.append(i)
    print(list2)
    

    输出结果如下:
    不会改变原列表元素顺序。

    [1, 2, 5, 6, 7, 4, 8, 9, 3]
    

    3.用列表推导式

    list1 = [1, 2, 5, 6, 7, 4, 8, 2, 7, 9, 4, 6, 3]
    list2 = []
    [list2.append(i) for i in list1 if not i in list2]  # append别忘记添加参数
    print(list2)
    

    输出结果如下:
    不改变原列表元素顺序

    [1, 2, 5, 6, 7, 4, 8, 9, 3]
    
    展开全文
  • 逆变器的重复控制

    万次阅读 多人点赞 2018-05-29 01:02:51
    1 内模原理与重复控制 内模原理的表述:在一个控制系统中,如果控制器的反馈来自被调节的信号,且在反馈回路中包含被控信号的动力学模型,那么整个系统是稳定的。内模原理的本质是是把外部信号的动力学模型植入...

    1 内模原理与重复控制

        内模原理的表述:在一个控制系统中,如果控制器的反馈来自被调节的信号,且在反馈回路中包含被控信号的动力学模型,那么整个系统是稳定的。内模原理的本质是是把外部信号的动力学模型植入控制器以构成高精度的反馈控制系统,这样的系统能够无静差的跟踪输入信号。

        对于阶跃信号l(t),其拉斯变换为1/s,所以包含PI控制器可以无静差的跟踪阶跃信号。对于交流信号,其拉斯变换为

    所以PI控制器是无法无静差的跟踪正弦信号的。PR控制器可以无静差的跟踪交流信号,PR控制器的传递函数是

    对于周期性的重复信号,典型的是带RCD负载的时候出现的周期性的电流扰动。定型的RCD负载的电流信号波形如下图:

    设重复信号周期为L,则其信号模型可以表示为

    其离散传递函数表示为

    其中N为一个周期的采样次数。包含上述内模的控制器就是重复控制器,它可以无静差的消除周期信号。

    2  重复控制器的结构

    重复控制的结构如下图所示

    对于上图框图中的重复控制器,受控对象是P(z),C(z)是补偿器,包括相位补偿和幅值补偿,为了简化,可以取C(z)等于

    Q(z)是为了增强系统的稳定性,是为了让系统的闭环极点为了单位圆内,一般去成小于1的常数,取Q(z)=0.95,重复控制器的传递函数H(z)等于可以

    3 重复控制编程实现

    重复控制传递函数为

    写成差分方程形式为

            N:一个周期内的采样次数

            K:相位补偿次数

    假设N=192,K=3,Kr=0.4,则用程序实现为:

    const int N=384;
    float y[N]={0};
    float e[N]={0};
    float Kr=0.4;
    const int K=4;
    float err;//控制误差
    float rpt;
    
    //err相当与当前拍误差,e[0]相当于err的前N拍
    //同理rpt相当于当前拍重复控制的输出量,y[0]相当于rpt的前N拍
    
    
    //计算误差err
    err=Vref-Vsample;
    
    //计算重复控制输出
    rpt=y[0]*0.95+e[K]*Kr;
    
    
    for(int i=0;i<N-1;i++)
    {
       e[i]=e[i+1];
       y[i]=y[i+1];
    }
    e[N-1]=err;
    y[N-1]=rpt;
    
    err+=rpt;

     

    4 逆变器重复控制Matlab建模

     

    逆变器系统的Matlab模型如下。逆变器用单相半桥逆变桥拓扑结构,电池组分正负俩个电池组,每个电池组电压360V。逆变器输出电压有效值220V。电阻设置为6M,模拟空载电阻无穷大的情况。开关Breaker在0.5s时闭合,模拟突加RCD满载的情况。RCD电阻设置为6欧姆,电容设置为4000uF。

    非线性负载模块详情

    控制模块Control的详情如下。重复控制器采用嵌入式结构,嵌入在PI电压环前面。逆变控制采用电压外环PI控制,电流内环比例控制。1302是50%占空比,这个占空比补偿是用来是的半桥在无控制输入时输出电压保持为0。

    重复控制模块的xiangq详情如下图。

     

    5 控制仿真

    只用PI-P控制不用重复控制时

    输出电压和参考电压波形,之前俩个波形基本重合,到0.5s加了RCD负载后输出电压就比较糟糕:

    输出电流波形,来看一下情况有多恶劣,电流峰值达到了200V:

    输出电压THD,THD后面维持在10%左右:

    采用重复控制以后

      输出电压和参考电压波形

     

    输出电压的THD,稳定在4.5%附近:

    输出电流波形:

    总结

        可见重复控制对于抑制RCD负载的效果非常好,带满载的时候THD都基本能稳定在4.5%左右。重复控制可调参数主要有幅值补偿系数和相位补偿系数。幅值补偿系数太过小的时候,重复补偿强度会很弱,效果不明显。重复控制系数过大的时候,重复控制会引起震荡。最终效果以在实际机器上调试为准,不过跟仿真基本差不离多少。下次有时间可以做一个用StateFlow编程驱动的更精确的模型出来。仿真模型已上传CSDN,仿真模型下载地址:https://download.csdn.net/download/liuzhijun301/12008303

     

    展开全文
  • easyui iframe 页面重复加载的问题

    热门讨论 2014-01-24 09:50:28
    解决使用tab布局过程中页面多次加载的问题 如果在使用easyui过程中,你使用了easyui 的tab布局,在tab布局的内容上使用的不是content,而是iframe,那么你的页面有可能多次加载了,这篇文章帮你解决问题
  • 重复数据在数据分析和搜索中会造成错误。在我们的实际使用中,我们应该避免重复导入的数据。重复数据有各种原因会造成。比如我们重复导入同样的数据。当我们写入文档时使用自动生成的 ID,那么同样的文档被导入两次...

    重复数据在数据分析和搜索中会造成错误。在我们的实际使用中,我们应该避免重复导入的数据。重复数据有各种原因会造成。比如我们重复导入同样的数据。当我们写入文档时使用自动生成的 ID,那么同样的文档被导入两次,这样会造成同样的两个一样的文档会保存于 Elasticsearch 中尽管它们的 ID 会有不同。在我之前的文章 “Beats:如何避免重复的导入数据”,我详细描述了如果使用 Beats 导入数据时,避免重复数据。

    避免在 Elasticsearch 索引中重复始终是一件好事。 但是,通过消除重复项,你可以获得其他好处:节省磁盘空间,提高搜索准确性,提高硬件资源管理效率。 也许最重要的是,你减少了搜索的获取时间。令人惊讶的是,有关该主题的文档很少,因此我们提供了本教程,为你提供识别和管理索引中重复项的适当技术。

    示例数据

    这里有四个简单的文档,其中一个是另一个的重复数据。 我们建立一个叫做 employeeid 的索引。

    POST employeeid/_bulk
    { "index" : { "_id" : "1" } }
    { "name" : "John", "organisation": "Apple", "employeeID": "23141A"}
    { "index" : { "_id" : "2" } }
    { "name" : "Sam", "organisation": "Tesla", "employeeID": "TE9829"}
    { "index" : { "_id" : "3" } }
    { "name" : "Sarah", "organisation": "Microsoft", "employeeID": "M54667"}
    { "index" : { "_id" : "4" } }
    { "name" : "John", "organisation": "Apple", "employeeID": "23141A"}

    从上面的命令中,我们可以看得出来 ID 为 1 和 4 的两个文档完全是一样的,尽管它们的 ID  是不同的。

    数据导入过程中避免重复文档

    在考虑如何在 Elasticsearch 中执行重复检查之前,让我们花点时间考虑一下不同类型的索引方案。

    一种情况是在索引编制之前我们可以访问源文档。 在这种情况下,检查数据并查找一个或多个包含唯一值的字段相对容易。 也就是说,该字段的每个不同值仅出现在一个文档中。 在这种情况下,我们可以将该特定字段设置为 Elasticsearch 索引的文档 ID。 由于任何重复的源文档也将具有相同的文档 ID,因此 Elasticsearch 将确保这些重复文档不会成为索引的一部分。

    你可以参考我之前的文章 “Beats:如何避免重复的导入数据”。

    Upsert

    另一种情况是一个或多个文档具有相同的标识符但内容不同。 当用户编辑文档并想使用相同的文档 ID 重新索引该文档时,通常会发生这种情况。 问题在于,当用户尝试重新索引时,Elasticsearch 不允许这样做,因为它的文档 ID 必须是唯一的。

    解决方法是使用 Upsert API。 Upsert 检查特定文档的存在,如果存在,Upsert 将使用 Upsert 的内容更新该文档。 如果文档不存在,Upsert 将创建具有相同内容的文档。 无论哪种方式,用户都将在相同的文档 ID 下获得内容更新。

    在第三种情况下,在创建索引之前无法访问数据集。 在这些情况下,我们将需要搜索索引并检查重复项。 这就是我们在以下各节中演示的内容。

    在写入数据时,我们可以使用 Upsert 来进行。如果该文档尚不存在,则将 Upsert 元素的内容作为新文档插入。 如果文档存在,则执行更新。比如:

    POST test/_update/1
    {
      "script": {
        "source": "ctx._source.counter += params.count",
        "lang": "painless",
        "params": {
          "count": 4
        }
      },
      "upsert": {
        "counter": 1
      }
    }

    在上面,如果 ID 为 1 的文档已经存在没那么将执行脚本,并把 count 的值加上 4。否则创建一个新的文档,并把 count 字段的值设置为 1。又比如:

    POST sessions/_update/dh3sgudg8gsrgl
    {
      "scripted_upsert": true,
      "script": {
        "id": "my_web_session_summariser",
        "params": {
          "pageViewEvent": {
            "url": "foo.com/bar",
            "response": 404,
            "time": "2014-01-01 12:32"
          }
        }
      },
      "upsert": {}
    }

    在上面,我们设置 scrpted_upsert 为 true。无论 ID 为 dh3sgudg8gsrgl 已经存在与否,id 为 my_web_session_summariser 的脚本将被执行,并把相应的参数传入。

    我们也可以直接使用 _update 对文档直接更新,比如:

    POST test/_update/1
    {
      "doc": {
        "name": "new_name"
      },
      "doc_as_upsert": true
    }

    在上面,如果 ID 为 1 的文档已经存在,那么它的字段 name 值将被更新,否则创建一个新的 ID 为 1 的文档,并设置它的字段 name 值为 new_name。

    在使用 Upsert 命令时,我们需要注意的是:我们必须提供一个 ID,另外它有两个操作:检查是否存在,并更新或者写入。Upsert 的速度会比正常的自动生成 ID 的导入速度慢。

    当我们使用 Logstash 进行导入时,我们也可以指定 Upsert

    检查重复项的基本技巧

    在上面的每个示例文档中,我们看到三个字段:name,organisation 及 employeeID,并且如果我们假设 name 字段是唯一的,则可以将该字段指定为检查重复项的标识符。 如果多个文档的 name 字段具有相同的值,则该文档确实是重复的。

    遵循此基本原理,我们可以执行简单的术语聚合,以获取 name 字段每个值的文档计数。 但是,这种简单的聚合只会返回该字段每个值下的文档计数。 这种方法在检查重复项时没有用,因为我们要检查文档中该字段的一个或多个值的重复项。 为此,我们还需要应用 top_hits 聚合 - 一个子聚合器,其中每个存储桶中均会聚合最匹配的文档。

    这是我们建议针对上面给出的示例文档索引的查询:

    GET employeeid/_search
    {
      "size": 0,
      "aggs": {
        "duplicateCount": {
          "terms": {
            "field": "name.keyword",
            "min_doc_count": 2
          },
          "aggs": {
            "duplicateDocuments": {
              "top_hits": {}
            }
          }
        }
      }
    }

    在这里,我们定义参数  min_doc_count。通过将此参数设置为 2,只有 doc_count 为 2 或更大的聚合桶将出现在聚合中(如以下结果所示)。

    上面的命令运行的结果是:

    {
      "took" : 1,
      "timed_out" : false,
      "_shards" : {
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        "total" : {
          "value" : 4,
          "relation" : "eq"
        },
        "max_score" : null,
        "hits" : [ ]
      },
      "aggregations" : {
        "duplicateCount" : {
          "doc_count_error_upper_bound" : 0,
          "sum_other_doc_count" : 0,
          "buckets" : [
            {
              "key" : "John",
              "doc_count" : 2,
              "duplicateDocuments" : {
                "hits" : {
                  "total" : {
                    "value" : 2,
                    "relation" : "eq"
                  },
                  "max_score" : 1.0,
                  "hits" : [
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "1",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "John",
                        "organisation" : "Apple",
                        "employeeID" : "23141A"
                      }
                    },
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "4",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "John",
                        "organisation" : "Apple",
                        "employeeID" : "23141A"
                      }
                    }
                  ]
                }
              }
            }
          ]
        }
      }
    }

    请务必注意,我们必须将 min_doc_count 的值设置为2。 否则,其他结果将出现在聚合中,并且我们将找不到可能存在的任何重复项。

    对多个字段中的值进行重复数据删除

    我们上面所做的是一个非常基本的示例,该示例根据单个字段中的值来标识重复文档。这不是很有趣。还是有用的。在大多数情况下,检查重复项需要检查多个字段。我们不能可靠地假设员工文档之间存在重复项,而这些重复项仅在名称字段中包含多次出现的 “Bill” 值。在许多实际情况下,有必要检查许多不同字段之间的重复项。考虑到上面的示例数据集,我们需要检查所有字段中的重复项。

    我们可以从上一节中扩展我们的方法,并执行多字段术语聚合和 top-hits 聚合。我们可以对索引文档中的所有三个字段进行术语聚合。我们将再次指定 min_doc_count 参数,以仅获取 doc_count 大于或等于 2 的存储桶。我们还应用 top_hits 聚合以获取正确的结果。为了容纳多个字段,我们使用脚本来帮助我们追加字段值以在聚合中显示:

    GET employeeid/_search
    {
      "size": 0,
      "aggs": {
        "duplicateCount": {
          "terms": {
            "script": "doc['name.keyword'].value + doc['employeeID.keyword'].value + doc['organisation.keyword'].value",
            "min_doc_count": 2
          },
          "aggs": {
            "duplicateDocuments": {
              "top_hits": {}
            }
          }
        }
      }
    }

    如下所示,运行此查询的结果将显示一个重复计数聚合。聚合 duplicateDocuments 包含在其中找到重复值的文档。 我们可以对这些文档进行交叉检查和验证。

    {
      "took" : 3,
      "timed_out" : false,
      "_shards" : {
        "total" : 1,
        "successful" : 1,
        "skipped" : 0,
        "failed" : 0
      },
      "hits" : {
        "total" : {
          "value" : 4,
          "relation" : "eq"
        },
        "max_score" : null,
        "hits" : [ ]
      },
      "aggregations" : {
        "duplicateCount" : {
          "doc_count_error_upper_bound" : 0,
          "sum_other_doc_count" : 0,
          "buckets" : [
            {
              "key" : "John23141AApple",
              "doc_count" : 2,
              "duplicateDocuments" : {
                "hits" : {
                  "total" : {
                    "value" : 2,
                    "relation" : "eq"
                  },
                  "max_score" : 1.0,
                  "hits" : [
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "1",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "John",
                        "organisation" : "Apple",
                        "employeeID" : "23141A"
                      }
                    },
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "4",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "John",
                        "organisation" : "Apple",
                        "employeeID" : "23141A"
                      }
                    }
                  ]
                }
              }
            }
          ]
        }
      }
    }

    从上面,我们可以看出来有一个重复的文档。

    假如我们把导入的文档修改为:

    POST employeeid/_bulk
    { "index" : { "_id" : "1" } }
    { "name" : "John", "organisation": "Apple", "employeeID": "23141A"}
    { "index" : { "_id" : "2" } }
    { "name" : "Sam", "organisation": "Tesla", "employeeID": "TE9829"}
    { "index" : { "_id" : "3" } }
    { "name" : "Sarah", "organisation": "Microsoft", "employeeID": "M54667"}
    { "index" : { "_id" : "4" } }
    { "name" : "John", "organisation": "Apple", "employeeID": "23141A"}
    { "index" : { "_id" : "5" } }
    { "name" : "Sarah", "organisation": "Microsoft", "employeeID": "M54667"}

    在上面,ID 为 1 和 4 为重复文档。3 和 5 的文档为重复文档。重新运行上面的查询,我们可以看到:

      "aggregations" : {
        "duplicateCount" : {
          "doc_count_error_upper_bound" : 0,
          "sum_other_doc_count" : 0,
          "buckets" : [
            {
              "key" : "John23141AApple",
              "doc_count" : 2,
              "duplicateDocuments" : {
                "hits" : {
                  "total" : {
                    "value" : 2,
                    "relation" : "eq"
                  },
                  "max_score" : 1.0,
                  "hits" : [
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "1",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "John",
                        "organisation" : "Apple",
                        "employeeID" : "23141A"
                      }
                    },
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "4",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "John",
                        "organisation" : "Apple",
                        "employeeID" : "23141A"
                      }
                    }
                  ]
                }
              }
            },
            {
              "key" : "SarahM54667Microsoft",
              "doc_count" : 2,
              "duplicateDocuments" : {
                "hits" : {
                  "total" : {
                    "value" : 2,
                    "relation" : "eq"
                  },
                  "max_score" : 1.0,
                  "hits" : [
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "3",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "Sarah",
                        "organisation" : "Microsoft",
                        "employeeID" : "M54667"
                      }
                    },
                    {
                      "_index" : "employeeid",
                      "_type" : "_doc",
                      "_id" : "5",
                      "_score" : 1.0,
                      "_source" : {
                        "name" : "Sarah",
                        "organisation" : "Microsoft",
                        "employeeID" : "M54667"
                      }
                    }
                  ]
                }
              }
            }
          ]
        }
      }

    如上所示,重复的文档都被显示出来了。

    展开全文
  • 前文 重复数据的情况分为两种: 单个字段 数据重复 多个字段 数据重复 所以该篇的内容就是包括 ...单个字段的重复数据查找 与 去重多个...要找出重复数据,我们首先想到的就是,既然是重复,那么数量就是大于 1...

    前文

     

    重复数据的情况分为两种:  

    单个字段 数据重复  

    多个字段 数据重复

    所以该篇的内容就是包括


    单个字段的重复数据查找  与 去重
    多个字段的重复数据查找  与 去重 

     

     

    正文

     

    示例  accountinfo 表数据如下:

     

    场景一   单个字段重复数据查找 & 去重

    我们要把上面这个表中 单个字段 account字段相同的数据找出来。

    思路 分三步 简述:

     

    第一步

    要找出重复数据,我们首先想到的就是,既然是重复,那么 数量就是大于 1  就算是重复。 那就是 count 函数 。

    因为我们要排查的是 单个 字段account ,那么就是需要按照 account 字段 维度 去分组。  那就是 group by 函数。

     

    那么我们第一步写出来的mysql 语句是:
     

     SELECT account ,COUNT(account) as count FROM accountinfo GROUP BY account;

    查询结果如下:

    第二步 

    没错,如我们所想,count大于1的即是 account为 A  和 B 的数据。

    那么我们稍作筛选,只把count大于1的数据的account  找出来。

     第二步,利用having 拼接筛选条件,写出来的mysql 语句是:

     SELECT account FROM accountinfo GROUP BY account HAVING COUNT(account) > 1;
    

    查询结果如下:

     第三步

    重复的account数据 A B 都找出来了,接下来我们只需要把account为A 和 B 的其他数据都一起查询出来。

    那就是利用第二步查出来的数据做为子查询条件,使用 IN 函数。

    第三步写出来的mysql 语句是:

     SELECT * FROM  accountinfo WHERE account IN
     (
     SELECT account FROM accountinfo GROUP BY account HAVING COUNT(account) > 1
     );
    

    查询结果如下:

    可以看到重复的数据都被我们筛选出来了。

     

    那么怎么去重呢? 也就是说,把重复的数据删掉。

    不,准确点应该说是,重复的数据都只留下一条即可,这才是去重。

    紧接着上面,毕竟去重的前提肯定是找重,上面我们已经实现找重了,所以紧接着进行去重。

    按照我们步骤三得到的图,就是我们需要删掉一条account为A的数据, 一条account为B的数据,去重结果图应该如下:

     

    思路也分三步简述:

    第一步

    删掉数据,我们一般选择接住主键来删除,所以我们考虑从id入手。

    再来看我们的重复数据:

     

    如果我们想在这些重复数据里面,每个都保留一条,如 account 为 A 中 id=10 的数据,  account 为B 中 id=20 的数据 ,那么第一步我们就得把这两条数据从上面的

    最终得到的数据 筛选出来,也就是按照 account分组,保留里面id最小的数据。使用 group by min 函数。

    所以去重我们第一步写出来的mysql 语句是:

    SELECT min(id) as id from (
    
    
     SELECT * FROM  accountinfo WHERE account IN
     (
     SELECT account FROM accountinfo GROUP BY account HAVING COUNT(account) > 1
     ) 
     
     
     ) a GROUP BY a.account

    查询结果如下:

     

    第二步

    想要保留的数据已经找出来了,那么接下来就是从所有的重复数据里面 删掉 不为 我们保留的数据 即可 。
    那么就是找出我们需要删除的id, 使用 not in 函数。

    所以去重我们第二步写出来的mysql 语句是:

    SELECT t1.id FROM (
    
    SELECT id  FROM accountinfo WHERE account IN (  SELECT account FROM accountinfo GROUP BY account HAVING COUNT(account) > 1) ) t1 
    
    WHERE t1.id NOT IN (
    
    
    SELECT min(id) AS id FROM (
    
    
     SELECT * FROM  accountinfo WHERE account IN
     (
     SELECT account FROM accountinfo GROUP BY account HAVING COUNT(account) > 1
     ) 
     
     
     ) a GROUP BY a.account
    
    )

    查询的结果为:

    对这个sql语句稍作文字说明:

    第三步,删掉第二步找出来的数据即可,根据id删除。

    所以第三步写出来的mysql语句是:
     

    DELETE FROM accountinfo WHERE id IN (
    
    SELECT t1.id FROM (
    
    SELECT id  FROM accountinfo WHERE account IN (  SELECT account FROM accountinfo GROUP BY account HAVING COUNT(account) > 1) ) t1 
    
    WHERE t1.id NOT IN (
    
    
    SELECT min(id) AS id FROM (
    
    
     SELECT * FROM  accountinfo WHERE account IN
     (
     SELECT account FROM accountinfo GROUP BY account HAVING COUNT(account) > 1
     ) 
     
     
     ) a GROUP BY a.account
    
    )
    
    )
    

     

    执行结果如下图:

     

    场景二  多个字段重复数据查找 & 去重

     

     示例  accountinfo 表数据如下:

     

     想要去重,我们的首要想到的也是先把 重复数据 找出来。

    现在的重复定义是, account 和 deviceId 都相同的 时候,这种数据就是重复数据(也就是上图绿色框出来的就是同时多个字段都存在重复的数据)。

    思路简述:

    第一步

    因为有了文章上半部讲到的单个字段重复的数据查找思路,所以到这边应该更好理解了。

    同样, account 和 deviceId 都相同的重复数据就是指, 这种数据存在的数量 大于 2,那么就是存在重复了。

    我们还是使用到了 group by  函数 和 count 函数 和 having and  函数(因为需要同时满足两个字段条件,使用and)。

    第一步写出来的mysql语句是:

    SELECT account, COUNT(account), deviceId, COUNT(deviceId) 
    FROM accountinfo 
    GROUP BY account, deviceId 
    HAVING  (COUNT(account) > 1) AND  (COUNT(deviceId) > 1) 

    查询出来的结果如下图:

    第二步

    一样 也是把第一步里的到的关键信息 account 和 deviceId做为子查询条件,从原表里把  account 和 deviceId 同时相同的数据都查找出来。

    第二步写出来的mysql语句是:

     

    SELECT t.* FROM  accountinfo t, (
    
    SELECT account, COUNT(account), deviceId, COUNT(deviceId) 
    FROM accountinfo 
    GROUP BY account, deviceId 
    HAVING  (COUNT(account) > 1) AND  (COUNT(deviceId) > 1) 
    ) a 
    
    WHERE t.account=a.account AND t.deviceId=a.deviceId 

     

    查询结果如下图:

     

    可以看到重复的数据都被我们筛选出来了,这些数据里面就是包含 account 和 deviceId 同时都相同的数据!

     

    去重

    第一步

    思路一样,我们对于重复的数据每个只保留一条,那就是把这些涉及重复的数据每个都找出一条,也是根据id入手。

    也就是在account为 C 且 deviceId 为 C333  三条重复数据里面,保留 id最小的 等于30 这一条;

    account为D 且 deviceId 为 D444  二条重复数据里面,保留 id最小的 等于40 这一条.

     

    所以第一步我们先写出来的mysql语句为:
     

    SELECT min(id) as id FROM (
    
    SELECT t.* FROM  accountinfo t, (
    
    SELECT account, COUNT(account), deviceId, COUNT(deviceId) 
    FROM accountinfo 
    GROUP BY account, deviceId 
    HAVING  (COUNT(account) > 1) AND  (COUNT(deviceId) > 1) 
    ) a 
    
    WHERE t.account=a.account AND t.deviceId=a.deviceId 
    
    )a  GROUP BY a.account,a.deviceId
    

    查询结果如下图:

     

     

    第二步

    就是从涉及重复数据里面,找出除了我们需要保留的id之外的那批id, 那就是需要我们执行删除的数据id。

    所以第二步我们先写出来的mysql语句为:

    SELECT t.* FROM  accountinfo t, (
    
    SELECT account, COUNT(account), deviceId, COUNT(deviceId) 
    FROM accountinfo 
    GROUP BY account, deviceId 
    HAVING  (COUNT(account) > 1) AND  (COUNT(deviceId) > 1) 
    ) a 
    
    WHERE t.account=a.account AND t.deviceId=a.deviceId 
    
    ) b   WHERE b.id
    
    NOT IN (
    
    
    SELECT min(id) as id FROM (
    
    SELECT t.* FROM  accountinfo t, (
    
    SELECT account, COUNT(account), deviceId, COUNT(deviceId) 
    FROM accountinfo 
    GROUP BY account, deviceId 
    HAVING  (COUNT(account) > 1) AND  (COUNT(deviceId) > 1) 
    ) a 
    
    WHERE t.account=a.account AND t.deviceId=a.deviceId 
    
    )a  GROUP BY a.account,a.deviceId
    
    )
    
    

    查询出来的结果为:
     

    那么最后删掉这些id的数据即可:

    DELETE FROM accountinfo WHERE id in (
    
    SELECT b.id  FROM  (  
    
    SELECT t.* FROM accountinfo  t, (
    
    SELECT account, COUNT(account), deviceId, COUNT(deviceId) 
    FROM accountinfo 
    GROUP BY account, deviceId 
    HAVING  (COUNT(account) > 1) AND  (COUNT(deviceId) > 1) 
    ) a 
    
    WHERE t.account=a.account AND t.deviceId=a.deviceId 
    
    ) b   WHERE b.id
    
    NOT IN (
    
    
    SELECT min(id) as id FROM (
    
    SELECT t.* FROM  accountinfo t, (
    
    SELECT account, COUNT(account), deviceId, COUNT(deviceId) 
    FROM accountinfo 
    GROUP BY account, deviceId 
    HAVING  (COUNT(account) > 1) AND  (COUNT(deviceId) > 1) 
    ) a 
    
    WHERE t.account=a.account AND t.deviceId=a.deviceId 
    
    )a  GROUP BY a.account,a.deviceId
    
    )
    
    )
    

    去重后结果为:

     

     

    该篇就到此吧。

     

     

    展开全文
  • 如何防止重复提交

    万次阅读 2019-06-20 09:50:39
    转载 如何防止重复提交 一、有很多的应用场景都会遇到重复提交问题,比如: 1、点击提交按钮两次。 2、点击刷新按钮。 3、使用浏览器后退按钮重复之前的操作,导致重复提交表单。 4、使用浏览器历史记录重复提交表单...
  • Google如何识别重复内容的主要版本

    千次阅读 2020-11-23 16:46:28
    Google如何识别重复内容的主要版本为什么将一组重复内容中的一个版本视为主要版本它是如何工作的?重复内容带走 识别重复内容的主要版本 我们知道Google不会惩罚Web上的重复内容,但是它可能会尝试确定与同一页面的...
  • springboot如何解决重复提交,接口短时间重复调用 在平时开发中,如果网速比较慢的情况下,用户提交表单后,发现服务器半天都没有响应,那么用户可能会以为是自己没有提交表单,就会再点击提交按钮重复提交表单,...
  • 在c或c++中,头文件重复包含问题是程序员必须避免的问题,也是很多新手容易犯错的问题。 为什么要避免头文件重复包含呢? &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 1.我们知道在编译c或c++...
  • R&SPSS重复测量方差分析

    万次阅读 2019-04-20 23:52:08
    最近在做重复测量方差分析,真的是走了很多弯路,足足花费了我两周的时间,因此在此写一篇博文,希望能给其他人提供一些参考。 先说建议: 建议使用SPSS,不要使用R,会省很多精力,我用R做了3天,失败了,然后改用...
  • mysql查询表里的重复数据方法

    万次阅读 2019-08-08 11:34:31
    -- 0.482ms 方法二 有两个意义上的重复记录,一是完全重复的记录,也即所有字段均重复的记录,二是部分关键字段重复的记录,比如Name字段重复,而其他字段不一定重复或都重复可以忽略。 1、对于第一种重复,比较...
  • C++——重复编译与重复定义

    千次阅读 2018-12-30 12:17:17
    重复编译可能造成重复定义,但重复定义的来源不只有重复编译 从代码变成可执行的程序,需要两个步骤 编译和链接 编译开始时,将所有#include头文件的地方替换成该头文件的代码 在编译阶段,编译所有源文件成为...
  • 这一层世界起作用,如果是重复抽样,每次可能结果的数量相同,每个可能结果的概率也就相同;如果是非重复抽样,每次的可能结果数量不同,导致概率不同。 有序 :在分步这一层世界起作用,如果N次抽样是有序的,那...
  • Rocketmq重复消费问题

    万次阅读 多人点赞 2019-02-25 11:32:03
    一.RocketMQ消息重复消费: 应用:通过Rocketmq异步发送极光数据推送至app端,在推送的同时将数据存入mysql数据库中 问题:在app端收到多条相同的推送消息 二.异常出现的原因 Rocketmq在消费消息时产生了异常,...
  • ArrayList去除重复元素

    千次阅读 多人点赞 2021-03-30 19:35:07
    Java中ArrayList去除重复元素(包括字符串和自定义对象) 文章目录Java中ArrayList去除重复元素(包括字符串和自定义对象)1、去除重复字符串2、去除ArrayList中重复自定义对象元素Person实体类: 1、去除重复...
  • 分清楚技术重复和生物学重复

    千次阅读 2020-11-23 13:04:54
    1.技术重复 同一个样品测多次。例如给某伙计取血样,测5次基因表达量 能得到的信息 1.这伙计精确的基因表达量 2.基因表达量测量方法的准确程度(看多次测量的重复性好不好) 使用场景 1.只关心这一个人的基因表达量,...
  • RocketMQ不解决消息重复问题,RocketMQ不解决消息重复问题,RocketMQ不解决消息重复问题,重要的事情说三遍。 基本上说我很讨厌有人问这个问题,问这个问题首先你对消息的生命周期缺乏理解,其次RocketMQ的定位不是...
  • SQL:查找或删除重复

    万次阅读 2018-04-18 07:27:07
    本文讲述如何查找数据库里重复的行。这是初学者十分普遍遇到的问题。方法也很简单。这个问题还可以有其他演变,例如,如何查找“两字段重复的行”(#mysql IRC 频道最近问到的问题)如何查找重复行 第一步是定义...
  • python 删除重复项There are many ways to remove duplicates from a Python List. 有很多方法可以从Python列表中删除重复项。 Using a temporary List and Looping 使用临时列表和循环 Using set() built-in ...
  • 看到很多人说在 QNAP NAS 上使用 `fdupes` 工具只能实现查找重复文件的效果,要删除文件只能对照生成的重复文件列表手动操作。这个说法其实是不对的,`fdupes` 完全支持自动去重功能。 以下正文说明了使用 `fdupes`...
  • javaWeb应用后端防止表单重复提交

    万次阅读 2019-05-29 15:24:54
    正常我们防止一个页面的表单重复提交有2种途径 1:客户端控制(比如js判断,按钮置灰不可用等等这个大家自行网上查询) 2:服务器端针对api自己多业务逻辑判断 实际使用的场景中,我们大多是2者结合起来做,不能把...
  • Python读取CSV 文件 去掉重复数据

    千次阅读 2019-12-12 16:40:54
    安装 xlrd 模块 和 pandas 模块 pip3 install xlrd pip install pandas Python 文件 导入pandas模块 ...import pandas as pd ...print("去重复后数量:"+len(formatList).__str__() ) 控制台输出为
  • MySQL 如何查找删除重复行?

    千次阅读 2019-04-12 12:51:05
    1. 如何查找重复行 第一步是定义什么样的行才是重复行。多数情况下很简单:它们某一列具有相同的值。本文采用这一定义,或许你对“重复”的定义比这复杂,你需要对sql做些修改。本文要用到的数据样本: create table...
  • SpringBoot如何防止重复提交

    万次阅读 2019-06-12 21:32:46
    场景:同一个用户在2秒内对同一URL的提交视为重复提交。 思考逻辑: 1.从数据库方面考虑,数据设计的时候,某些数据有没有唯一性,如果有唯一性,要考虑设置唯一索引,可以避免脏数据。 2.从应用层面考虑,首先...
  • RabbitMQ消息重复消费场景及解决方案

    万次阅读 2021-03-09 13:41:22
    这里介绍一下RabbitMQ重复消费的场景,以及如何解决消息重复消费的问题。 目录 消息重复消费: MQ的一条消息被消费者消费了多次: 重复消费场景重现测试: 如何解决消息重复消费的问题(单消费者场景): 编码:...
  • Androud 如何有效减少重复代码

    千次阅读 2017-12-07 11:18:50
     重复的代码一直都是可维护性的大敌,重构的重要任务之一也就是要去除掉重复的代码,有效的减少重复代码,可以大大提高软件的扩展性。  在Android开发中,很容易产生重复的代码。因为Android是组件,模板式开发,...
  • 前不久我们项目中由用户反馈说遇到笔记重复的问题,而且不只一次遇到类似的反馈。 这种重复笔记总是出现的feed流的中间位置,如下示意图所示: 这个图画的有点丑,凑合看,意思大概就是这样的。 接下来,我就得追踪...
  • 删除单链表中的重复节点(c语言版本)

    千次阅读 多人点赞 2019-03-20 14:02:42
    (1)删除有序链表的重复节点,重复节点一个都不留 (2)删除有序链表的重复节点,重复节点只留一个 (3)删除无序链表的重复节点,重复节点只留一个 下面是相关节点的定义: typedef struct ListNode { int ...
  • 透彻解读mysql的可重复读、幻读及实现原理

    万次阅读 多人点赞 2019-05-15 15:21:30
    目录 一、事务的隔离级别 二、mysql怎么实现的可重复读 ...事务隔离级别有四种,mysql默认使用的是可重复读,mysql是怎么实现可重复读的?为什么会出现幻读?是否解决了幻读的问题? 一、事务的隔离级别 Re...
  • 给出一个字符串 S,考虑其所有重复子串(S 的连续子串,出现两次或多次,可能会有重叠)。 返回任何具有最长可能长度的重复子串。(如果 S 不含重复子串,那么答案为 ""。) 方法1:后缀数组法 // 后缀数组法 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,465,879
精华内容 1,386,351
关键字:

重复