MongoDB阿司匹林

基本上,这是我使用Mongo时遇到的常见错误/任务/问题列表。一世’我记下了通常有效的方法。可能是你’会发现它很有用ðŸ™,

为什么我的远程mongodb连接被拒绝了?

1
2
3
4
pymongo 进口 MongoClient
c = MongoClient(“某些IP地址”)
...
pymongo.错误.连接失败: 可以 连接 123.456.0.1:27017: [Errno 111] 连接 被拒绝

    • 删除 蒙哥.从您的主要mongodb存储文件夹中选择文件,然后重新启动[ 所以 ]
    • 如果使用redhat,请检查  塞斯塔图斯
    • 修改 / 等等 /系统配置/iptables按照以下说明具有正确的防火墙规则 蒙哥b文档.

您如何在pymongo中遍历所有mongoDB集合? 

我通常将集合作为对象属性来访问,例如:  康恩.数据库.采集.找一个()但实际上,数据库和连接也可以作为字典中的键来访问:

1
2
3
4
5
6
7
8
9
10
11
pymongo 进口 MongoClient
康恩 = MongoClient() #使用它代替Connection()
 
这里使用#[1:]是因为第一个集合是system.indexes
对于 采集 康恩.数据库.采集_names()[1:]:
    #做点什么
    康恩.数据库[采集].找一个()
 
#我们可以这样说:
康恩['数据库'].采集.找一个()
康恩.数据库['采集'].找一个()

为什么mongod每当我关闭外壳时都会终止?即使使用 &最后

启动mongod时,请使用 蒙哥 - 叉子Â(注意:fork必须在mongod一词之后),它将作为后台进程启动。或者只是添加 叉子 = 真正到您的配置。

我刚刚创建了一个经过身份验证的数据库,并且可以’t even 我们 e 节目 数据库 一种 !

创建具有以下所有4个权限的新用户:userAdminAnyDatabase,readWriteAnyDatabase,dbAdminAnyDatabase,clusterAdmin:

的JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
> D b .添加用户({ 用户: “ hilarious_name”, 密码 : “值得纪念的”, 角色: ['clusterAdmin','userAdminAnyDatabase', 'dbAdminAnyDatabase' 'readWriteAnyDatabase'] } )
{
        “用户” : “ hilarious_name”,
        “ 密码 ” : “ 0c3032130d7123a36c1913b2f55a3c84”,
        “角色” : [
                “ clusterAdmin”,
                “ 用户AdminAnyDatabase”,
                “ readWriteAnyDatabase”,
                “ D b AdminAnyDatabase”,
        ],
        “_ID” : 对象编号(“ 535956f010b65cad1f7906f7”)
}

蟒蛇多处理中的共享变量以预映射/减少

I’我最近在Python中使用了多处理库,并开始使用共享变量功能。它可以改变我这样的事情 以前的帖子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
多处理 进口 池子
pymongo 进口 连接
 
定义 多少(server_number):
    “返回集合中有多少个文档”
    c = 连接(“ 192.168.0。” + server_number) #连接到远程数据库
    返回 c.我的数据库.我的收藏.计数()
 
池子 = 泳池(流程=4)
伺服器 = [1,2,3,4]
结果 = 池子. 地图 (多少,伺服器) #map阶段
池子.()
 
#减少阶段
结果 = (结果)
 
打印 "您 have {0} docs across all MongoDB 伺服器!".格式(结果)

变得更好:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
多处理 进口 , 池子
pymongo 进口 连接
 
定义 多少(server_number):
    “返回集合中有多少个文档”
    c = 连接(“ 192.168.0。” + server_number) #连接到远程数据库
    shared_count. + = c.我的数据库.我的收藏.计数()
 
#设定
池子 = 泳池(流程=4)
伺服器 = [1,2,3,4]
shared_count = ( “一世” , 0)
 
结果 = 池子. 地图 (多少,伺服器) #map阶段
池子.()
 
打印 "您 have {0} docs across all MongoDB 伺服器!".格式(shared_count)

从而省去了还原阶段。如果您有一个共享字典,这特别有用。’从多个服务器重新更新。那里’是另一个可能的共享数据类型,称为Array,正如建议的那样,它是共享数组。 注意: 一个陷阱(我爱上了)认为 “一世” ( “一世” , 0)是变量的名称。其实,它的 类型码 代表“integer”.

但是,还有其他方法可以做到这一点,每种方法都有其自身的取舍:

# 优点 缺点
1 共享文件 易于实施和访问后 非常慢
2 共享的mongoDB文档 易于实施 缓慢不断查询
3 多处理值/数组(此示例) 非常快,易于实施 仅在一台PC上,可以’进程被杀死后无法访问
4 Memcached共享价值 网络方面对于大型分布式数据库很有用,shared.set()函数已经可用 TCP可能会使您慢一点

OrderedDict的快速解决方案’O(1)索引查找在Python中的限制

问题的背景

我定期处理巨大的机器学习数据集。一种非常通用的格式,用于 威卡 是 “ARFF”(属性关系文件格式)。这本质上创建了一个结构良好的丰富CSV文件,可以轻松地在Logistic回归,决策树,SVM等中使用。为了解决CSV数据非常稀疏的问题,有一种稀疏的ARFF格式可以让用户转换稀疏的行在每个文件中,例如:

f0 f1 f2 f3 fn
1 0 1 0 0

进入更简洁的版本,其中您具有功能列表,只需指定功能’的索引和值(如果有):

@ATTRIBUTE f0数值
@ATTRIBUTE f1数值
@ATTRIBUTE f2 NUMERIC
@ATTRIBUTE f3 NUMERIC

@属性fn数字
@数据
{0 1,2 1}

{feature-index-zero为1,feature-index-two为1}, 只需忽略所有零值。

实施问题

如果您有4个功能,这很容易,但是如果您有超过100万个功能并且需要找到每个功能的索引,该怎么办?在列表中搜索特征是O(n),并且如果您的训练数据也很大,那么创建稀疏的ARFF将会非常低效:

1
2
3
4
5
6
7
8
9
特征 = ['名称', 'some_metric', “ 一个 _attribute”, 'some_boolean']
 
#搜索特征的存在为O(n)
>>> 'some_metric' 特征
真正
 
#检索列表中要素的索引也是O(n)
>>> 特征.指数('some_metric')
1

我以为可以通过使用OrderedDict来改善这一点。很简单,这是一个维护其项目顺序的字典–因此您可以以类似堆栈的方式从最后弹出()项目。但是,之后 关于StackOverflow的一些研究,这令人失望’包含任何有效的方法来计算键的索引:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
馆藏 进口 OrderedDict
特征 = ['名称', 'some_metric', “ 一个 _attribute”, 'some_boolean']
od = OrderedDict()
对于 f 特征:
     od [f] = 0
 
#搜索特征的存在为O(1)
>>> 'some_metric' od
真正
 
#尽管检索列表中要素的索引仍然是O(n)!
>>> 特征.().指数('some_metric')
1
#keys()必须创建内存中所有键的完整列表,才能
#retrieve the 指数. 您 可以 我们 e iterkeys() 至 improve memory
#performance,但仍然很可笑。

解决方案

什么can we do about this? Enter my favorite 事情 ever, 定义 aultdicts 与 拉姆达s:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
馆藏 进口 定义 aultdict
特征 = ['名称', 'some_metric', “ 一个 _attribute”, 'some_boolean']
dd = 定义 aultdict(拉姆达: ( dd ))
 
对于 f 特征:
     dd [f] #不需要给它一个值,只需要调用它
 
#所以现在我们可以在O(1)中进行查找
>>> 'some_metric' dd
真正
 
#并在O(1)中获得其索引
>>> dd ['some_metric']
1

稍微修改一下lambda,除了索引之外,分配项目值也很简单:

1
2
3
4
5
6
7
8
9
10
11
dd = 定义 aultdict(拉姆达: {'指数':( dd )})
 
#然后可以无缝添加更多信息:
 
dd ['some_metric']['信息'] = 1
dd ['some_attribute']['信息'] = 2
 
#保持自动生成索引的O(1)查找:
 
>>> dd ['some_attribute']['指数']
1

 局限性

这是一个有趣的修复程序,但没有’支持完整的词典功能– deleting 项目s won’重新排序索引,您可以’轻松地依次进行迭代。但是,由于在创建此ARFF文件时,’无需删除或迭代’s 不 a problem.

WNYC电台:“黑客马拉松值得吗?”

WNYC电台的记者Jeff Coltin最近与我联系,要求我参加 显示关于黑客马拉松 在纽约。

他精选了我们谈话中的一小段内容,特别是有关黑客社区可以解决的问题。我说(模糊准确的转录):

“…骇客马拉松可以解决的问题太多了。我认为目前媒体上存在一些重大问题,例如NSA间谍丑闻之类的东西。我认为技术社区略有失败的一件事是使加密变得非常容易。那里’是简单性和安全性之间的一种反向关系,因此应用程序越安全,通常使用起来就越不方便。 TOR ,超长密码(TOR会大大降低您的连接速度),VPN和许多非常安全的服务与主流服务不兼容。因此,用户想要或需要的这种级别的安全性和隐私非常不便,这实际上取决于黑客社区,使他们更易于使用…”

已经进行了诸如 隐猫 但其采用率仍需要提高。 HTTPS可能是无缝加密的最佳示例,但是当人们对HTTPS证书被浏览器标记为无效时,人们无视或不知所措时,通常会失败。

密码学是计算机科学领域一个极为艰巨的领域,因此很难创建可靠的安全应用程序。对此进行自我教育可能需要相当超人的努力,而且我非常尊重做出贡献的人们 模组s 在 this field 至 PyPI。一世’我希望开始 Coursera上的加密课程 一旦我有更多的空闲时间,但是击败我提到的安全性-简单逆关系肯定说起来容易做起来难。

在哈佛用软件木工教授Python

BScO7AGIMAAvVZj.jpg-中

Mike用Python教Hamlet。照片版权Chris Erdmann: //twitter.com/libcce/status/371281901191196672

I’是纽约市名为Software Carpentry的组织的一部分。它使用志愿者向大学,大型政府组织和其他感兴趣的人群教授不同级别的编程。我之前曾在哥伦比亚大学任教,上周末在哈佛大学举办,由 克里斯·埃德曼,哈佛-史密森天体物理学中心的首席图书馆员。

在使用Software Carpentry之前,我的教学经验仅限于向亲朋好友讲解编程方面的内容,以及在日本为儿童和成人教英语和法语的一年时间的一部分。教学很难。它’批评老师很容易– I’我经常发现自己是如此,而没有考虑将复杂的概念传达给一群背景和动机各不相同的学生的努力和压力。一世’ve从我最近的两次SWC活动中得出了有关如何优化教学风格的一些结论:

星期六’s Teacher 线-up

运作良好的事情

  • 幽默。迈克在教程中撒了一些有趣的轶事,这使全班都很活跃。
  • 相关和有趣的主题。哈姆雷特(Hamlet)是一个不错的选择,因为面向图书管理员的观众也喜欢在拼字游戏中作弊。字典带来了几个有趣的条目,例如:  grep “。* s。* s。* s。* s。* s。* s” |
  • 添加轶事来拯救人们谷歌搜索。我认为很多程序员’他们的活动仅仅是寻找一个’已经完成了您想做的事情,并做了一些修改–或连接构建块。因此,在结束时谈论诸如 附加()VS与加号等串联 第一+第二 , I mentioned 东西 like 双端队列()和  格式() 一种 。

下次要记住的事情

  • 慢慢打字。我在MongoDB上工作很多,所以最终从 pymongo 进口 连接; c = 连接()  20+ times a day 整型 o the terminal. This can become so fast, 东西 like that can seem bewildering 至 newcomers.
  • 使用带有大字体和昏暗灯光的高对比度终端,使其从房间的背面超级容易看清。

什么can advanced programmers get 出 的 教学 such basic 东西?

  • 您’从老师和学生那里学到很多东西’s questions
  • 社区参与是简历中的一项重要资产,它向潜在的雇主表明您有能力/有能力培训未来的同事
  • 当在社会或商业上向非技术人员解释技术问题时,它有助于在教学过程中掌握现有的类比和轶事。
  • 您’会遇到许多志同道合的人,参与社区的感觉很棒。

什么did I learn?

  • 要求 图书馆。我通常使用 网址 lib2 从网页抓取HTML。事实证明,Urllib2只是一个用于HTTP请求的可扩展性更大的库,如下所示 stackoverflow说明.
  • 有关Git的更多信息。我在工作中使用SVN,因此不要’真的向github提交任何东西。 Git很难。 Erik是一位出色的讲师,从容不迫地从基础知识过渡到了.gitignore和diff之类的细节。
  • 什么“immutable” really means. I hear this thrown around quite a lot 和 it basically just means 东西 can’被分配给一个对象。例如。的。 分裂()myString.分裂()可以’t成为变量。非常简单。

数据科学商业评论(O’Reilly, 2013)

封面

I’m目前正在参加 O’Reilly Blogger评论计划 – wh给博客作者提供了最近出版物的电子书。 

商业数据科学适应市场中一个有趣的缺口–希望能够了解什么是数据科学,如何招聘数据科学家或如何管理面向数据的团队的管理人员。它说它也适合有抱负的数据科学家,但我可能会建议 吴安德’机器学习课程 和 密码学’的Python入门课程 相反,如果你’认真对待将牙齿伸向田间的想法。

在介绍和百科全书之间的某个地方,它提供了每个子领域的相当全面的概述,包括我以前没有的区别’以前没有这么清楚地想过。作者大多不敢解释主题背后的数学。它陷入某种概率和线性代数–公认的简化符号。那里’没有真正提到实现(即,对示例进行编程),就像人们通常期望的那样’赖利;但是大多数有能力的读者现在至少会知道他们’re “looking 对于 ” perhaps 在 terms 的 包装要安装,或者他们想尝试从头开始实施系统。它当然是为聪明,专业和远离大众科学而设计的。

尽管它非常彻底且有趣,但它可能会引起数据科学家的不安,因为数据科学家的经理是否真的必须阅读这样的书?–当然,在这样的权威地位,他们应该已经了解这些技术了吗? (一个极端的例子是一个脚注,其中甚至包含对Facebook的含义及其用途的描述)。通常,这种不平衡的层次结构是导致工作场所不必要的压力和复杂化的原因。但是,通常是这种情况,因此在这种情况下也许会很有用。

我认为,总的来说,我希望本书有所不同–关于如何将现有的数据科学知识应用于业务场景的更深入的案例研究。尽管如此,它’这是一个有趣的,智能的百科全书指南,其解释和可访问性清晰明了–我非常怀疑我能否在这方面写出更好的指南。现有的数据科学家会发现许多清晰的类比,向技术水平不高的人解释他们的技术,我认为,就其本身而言,看一看就够了

当literal_eval失败时:使用星号表示法读取日期时间对象

python中的一项重要功能是 AST ((抽象语法树) 图书馆’s 文字评估一种 。这使您可以读取python数据类型的字符串版本:

1
2
3
4
5
6
7
8
9
>>> AST 进口 文字评估
>>> #带有一些琐碎信息的示例字典
>>> myDict = “ {'someKey':1,'otherother':2}”
>>> #让我们使用函数进行解析
>>> testEval = 文字评估(myDict)
>>> 打印 testEval
{'someKey': 1, “ otherKey”: 2}
>>> 类型(testEval)
<类型 'dict'>

像这样导入字典类似于 解析JSON 使用Python’s  json.负载解码器。但是它也有缺点’s 的 JSON’s的限制性数据类型,如我们在字典中包含例如datetime对象时所见:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> myDict = “ {'someKey':1,'rightNow':datetime.datetime(2013,8,10,21,46,52,638649)}“
>>>
>>> 文字评估(myDict)
追溯 (最近 呼叫 持续 ):
  文件 "<stdin>", 线 1, <模组>
  文件 “ /root/anaconda/lib/python2.7/ast.py”, 线 80, 文字评估
    返回 _兑换(节点_or_string)
  文件 “ /root/anaconda/lib/python2.7/ast.py”, 线 63, _兑换
     压缩 (节点., 节点.价值观))
  文件 “ /root/anaconda/lib/python2.7/ast.py”, 线 62, <基因>
    返回 字典((_兑换(k), _兑换(v)) 对于 k, v
  文件 “ /root/anaconda/lib/python2.7/ast.py”, 线 79, _兑换
    提高 值Error(“格式错误的字符串”)
值Error: 畸形的

因此,您可以尝试编写一些代码来自己解析字典数据类型。这变得非常棘手,但是最终您可能可以容纳所有常见的数据类型:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
定义 read_dict(d):
    “接受包含字典的字符串。
    试图对此进行解析并返回字典。”
    parsed_dict = {} #结果
    #删除{}并分成大块
    d = d[1:-1].分裂(',')
    #遍历大块并尝试解释它们
     对于 kv_pair d:
        #由中央结肠分裂
        kv_pair = kv_pair.分裂(“:”)
        #解释键和值
        k = 我是什么(kv_pair[0])
        v = 我是什么(kv_pair[1])
        #添加到最终解析的字典中
        parsed_dict[k] = v
    返回 parsed_dict
 
定义 我是什么(事情):
    “解释字符串的简单尝试
    数据类型。可以处理字符串和整数”
    #删除任何反引号
     如果 事情.以。。开始( “” ) 要么 事情.以。。开始( “” ):
        事情 = 事情[1:-1]
 
    #Now检查数据类型(尽管还有更多方法)
     如果 事情.等轴():
        返回 整型 (事情) #返回数字
    其他:
        返回 事情 #返回字符串
    #如果任何一个都无法识别,则返回错误
    返回 “数据损坏”

但这仍然没有’真正解决我们的日期时间对象问题:

1
2
3
4
5
>>> read_dict(myDict)
追溯 (最近 呼叫 持续 ):
  文件 "<stdin>", 线 1, <模组>
  文件 "<stdin>", 线 13, read_dict
IndexError: 清单 指数 范围

这是本文重点所在。起初我以为我可以处理日期时间’通过提取类来格式化  约会时间.约会时间(2013, 8, 10, 21, 46, 52, 638649)作为一个元组,可以通过发现方括号,然后将其返回到日期时间,例如: 

1
2
3
4
5
>>> x = (2013, 8, 10, 21, 46, 52, 638649)
>>> parsedDate = 约会时间(x)
追溯 (最近 呼叫 持续 ):
  文件 "<stdin>", 线 1, <模组>
TypeError: 一个 整数 需要

但显然不是。必须提取元组–不是通过lambda或列表理解,而是实际上使用星号表示法:

1
2
3
>>> parsedDate = 约会时间(*x)
>>> 打印 parsedDate
2013-08-10 21:46:52.638649

星号(*)将x等可迭代程序解压缩为该函数的位置参数。简单!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
定义 我是什么(事情):
    “解释字符串的简单尝试
    数据类型。可以处理str,int,datetime”
    #删除任何反引号
     如果 事情.以。。开始( “” ) 要么 事情.以。。开始( “” ):
        事情 = 事情[1:-1]
 
    #现在检查某些数据类型
     如果 事情.等轴():
        返回 整型 (事情) #返回数字
    小精灵 事情.以。。开始('约会时间'):
        #获取括号之间的数字
        事情 = 事情.分裂( '(' )[1].分裂( ')' )[0]
        #解析数字,解压缩为日期时间并返回
        返回 约会时间(*[ 整型 (x) 对于 x 事情])
    其他:
        返回 事情 #返回字符串
    #如果任何一个都无法识别,则返回错误
    返回 “数据损坏”

使用ACORA一次处理数百个停用词

“80%的数据分析是花费在清洁数据上,其中20%的花费是在抱怨清洁数据” – 长社大数据宝

这是我听到的最好的报价之一 PyData 2013。当处理大量数据时,通常只有一小部分与一个数据相关 ’的分析,尝试清洁它可能会很痛苦。但这也是 基本阶段, 所以让’使它尽可能的无痛。

一个示例是巨大的日志文件。说我们’重新处理多TB的Apache日志文件,如下所示:

1
2
3
4
5
6
7
8
9
10
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-dropdown.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-scrollspy.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-tab.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-tooltip.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-popover.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-button.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-collapse.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-carousel.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:38 -0500] “获取/static/js/bootstrap-typeahead.js HTTP / 1.1” 304 - "http://127.0.0.1/" “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”
127.0.0.1 - - [17/ 七月 /2013:07:22:39 -0500] “ GET /favicon.ico HTTP / 1.1” 404 4025 “-” “ Mozilla / 5.0(Macintosh;英特尔Mac OS X 10_7_4)AppleWebKit / 537.36(KHTML,例如Gecko)Chrome / 28.0.1500.71 Safari / 537.36”

这是包含数千行的有用数据,我们’d想使用 我之前提到的大文件处理脚本。但是,有些行’不关心–所以你可以写一个简单的条件:

1
2
3
4
打开('mylogfile.txt', 'r' ) f:
     对于 线 f:
         如果 “ some_keyword” 线:
            做点什么()

什么if you have 2 东西 that you don’t want 在 each 线?

1
2
3
4
打开('mylogfile.txt', 'r' ) f:
     对于 线 f:
         如果 (“ some_keyword” 线) (“ other_keyword” 线):
            做点什么()

什么if you have 3 东西 that you don’t want 在 each 线?

1
2
3
4
5
6
7
8
9
打开('mylogfile.txt', 'r' ) f:
     对于 线 f:
        线_is_ok = 真正
         对于 停用词 [“ some_keyword”, “ other_keyword”, “不”]:
             如果 停用词 线:
                线_is_ok =
                打破 #退出循环
         如果 线_is_ok: #仅在line_is_ok未被篡改的情况下处理行
            做点什么()

但这变得超级低效,有点愚蠢。每个额外的关键字都需要通过该行。使用此代码,基本上所有情况都是最坏的情况。

带上ACORA!

阿科拉 是Stefan Behnel’的库基于 Aho-Corasick字符串匹配算法。无需深入了解其背后的数学原理,它基本上会将您拥有的所有停用词都编译为单个¼-停用词,这意味着在您的日志文件行中对该停用词进行一次扫描将检查所有停用词。例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
阿科拉 进口 AcoraBuilder
 
#创建停用词列表-这些是条目
#我们想忽略的
停用词 = ['.js', '.ico', '.css', '.jpg', ...]
 
#将它们输入新的Acora Builder中
停用词_matcher = AcoraBuilder()
对于 停用词 停用词:
    停用词_matcher.(停用词)
 
#now让它构造超级停用词
停用词_matcher = 停用词_matcher.建立()
 
#this使用生成器迭代匹配项
#发现任何东西都会停止
对于 比赛 停用词_matcher.寻找者(线_from_log_file):
    打印 “找到匹配:{0}”.格式(比赛)

但是我们如何将其从以前集成到行扫描器中呢?像这样!

1
2
3
4
5
6
7
8
打开('mylogfile.txt', 'r' ) f:
     对于 线 f:
        线_is_ok = 真正
         对于 比赛 停用词_matcher.寻找者(线):
            线_is_ok =
            打破 #退出循环
         如果 线_is_ok:
            做点什么()

We’ve用单个ACORA匹配器替换了整个多个停用词匹配的for循环。

性能说明

阿科拉很棒,但是如果只有几个停用词或只有几行,性能可能会下降。当您有大约20个以上的停用词并且至少有1000个左右的日志文件行要扫描时,它的性能最佳。

提取TLD(顶级域)–和怪异的怪癖会让你不高兴

I’ve been 我们 ing 约翰·库科夫斯基‘优秀的Python域提取库“葡聚糖”最近,TLDextract可以很容易地从URL中提取域名,例如:

1
2
3
>>> 葡聚糖 进口 提取
>>> 提取('http://stjamespublichouse.com/?p=106')
提取结果(子域= '' , ='ikigomu', 顶级域名 ='com')

为什么这有用?

这有很多应用–例如,如果您要创建链接到您网站的热门域名的摘要,则可能会有很多引荐网址:

1
ref_urls = ["http://www.google.com/somesearch", "http://sub.othersite.com/something", "//www.google.com/images", "http://xyz.yahoo.com/sample"] #etc等

您可以编写一些简单的代码来输出域:

1
2
3
4
5
6
7
8
9
葡聚糖 进口 提取
 
定义 抢域( 网址 ):
    “返回URL的域”
     尝试 :
         网址 = 提取( 网址 )
    例外:
        提高 例外(“此URL不起作用:{0}”.格式( 网址 ))
    返回 '。' .加入(( 网址 [1], 网址 [2])) #连接域名和tld

并使用 词频计算器 从我以前的帖子中汇编出最热门的引用域名列表!看到我’ve修改了第10行,改为将域添加为键:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
算子 进口 项目获取器
馆藏 进口 定义 aultdict
 
定义 域_frequencies(l):
    “获取网址列表'l'并返回列表清单
      其中每个项目是[域,频率],已排序
       descending."
    all_freqs = 定义 aultdict( 整型 ) #暂时保存值
     对于 项目 l:
        all_freqs[抢域(项目)] + = 1 #将域添加到defaultdict
    #将字典转换为列表列表
    all_freqs = [[k,v] 对于 k,v all_freqs.重复项()]
    #返回排序后的版本
    返回 已排序(all_freqs, =项目获取器(1), 逆转= 真正 )

哪个返回:

1
2
>>> 域_frequencies(ref_urls)
[[“ google.com”, 2], [“ yahoo.com”, 1], [“ othersite.com”, 1]]

为什么可以’你在第三个斜杠处用句号分隔’s before?

这是我一开始尝试做的事情:

1
2
3
4
5
定义 抢域( 网址 ):
    返回 网址 .分裂( '/' )[2].分裂( '。' )[-2:]
 
>>> 抢域("http://www.google.com/something")
>>> ['谷歌', 'com']

但是由于域名系统是顶级域名(例如.com),二级域名(例如.gov.uk),标准子域名(egiimgur.com)以及那些句号过多的人(例如www.dnr。 state.oh.us)变得更加棘手,无法容纳所有内容。因此TLDextract实际上维护着Mozilla的本地副本’您系统上的ICANN域的列表,从以下位置下载: 

http://mxr.mozilla.org/mozilla-central/source/netwerk/dns/effective_tld_names.dat?raw=1

并从中基本上找到URL末尾的匹配项。非常好!

所以呢’标题中提到的问题?

不幸的是,使用Mozilla的警告’的清单是您得到一些看似奇怪的行为。有许多网站和公司从亚马逊请求其子域为TLD,并包含在列表中:

的JavaScript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Amazon CloudFront : //aws.amazon.com/cloudfront/
//由Donavan Miller请求<[email protected]> 2013-03-22
云前.
 
// Amazon Elastic Compute Cloud: //aws.amazon.com/ec2/
//由Osman Surkatty请求<[email protected]> 2013-04-02
计算.亚马逊. com
我们 --1.amazonaws.com
计算-1.amazonaws.com
z-1.计算-1.amazonaws.com
z-2.计算-1.amazonaws.com
ap -东北-1.计算.amazonaws.com
ap -东南-1.计算.amazonaws.com
ap -东南-2.计算.amazonaws.com
欧盟 -西方-1.计算.amazonaws.com
SA --1.计算.amazonaws.com
我们 - 政府 -西方-1.计算.amazonaws.com
我们 -西方-1.计算.amazonaws.com
我们 -西方-2.计算.amazonaws.com
 
// Amazon Elastic Beanstalk : //aws.amazon.com/elasticbeanstalk/
//由Adam Stein请求<[email protected]> 2013-04-02
弹豆. com

要DynDNS的东西:

的JavaScript
1
2
3
4
5
6
7
8
9
--认证的. com
-已保存. 组织
-圆滑的. com
-优步. com
-非常-. 组织
-非常- 邪恶 . 组织
-非常-. 组织
-非常-不错. 组织
-非常-. 组织

和更多… So you’如果您输入以下内容,将会绊倒:

1
2
>>> 提取("//scriptgang.elasticbeanstalk.com/getMagazine.html")
提取结果(子域= '' , ='脚本帮', 顶级域名 ='elasticbeanstalk.com')

而不是预期的“.com” 如 the 顶级域名 .

简洁的方式来构建可迭代的Python频率表

这是编程中一个有趣且经常解决的任务,在NLP和数据科学中尤其普遍。通常有一个清单“things”有很多重复,并想知道哪些是最受欢迎的。

资料范例

1
我的清单 = [1,1,1,1,5,5,5,3,2,2,2,3,4,5,5,5,5,5,5,6,6,6,6]

要么:

1
my_sentence = “猫坐在垫子上看报纸”

哪个最受欢迎的号码?最受欢迎的字母是哪一个?

编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
馆藏 进口 定义 aultdict
算子 进口 项目获取器
 
定义 freq_table(l):
    “获取列表'l'并返回列表列表
      每个项目都是['item',frequency],已排序
       descending."
    all_freqs = 定义 aultdict( 整型 ) #暂时保存值
     对于 项目 l:
        all_freqs[项目] + = 1 #添加到字典
    #将字典转换为列表列表
    all_freqs = [[k,v] 对于 k,v all_freqs.重复项()]
    #返回排序后的版本
    返回 已排序(all_freqs, =项目获取器(1), 逆转= 真正 )

对于我们的数据,我们现在得到:

1
2
>>> freq_table(我的清单)
[[5, 9], [1, 4], [6, 4], [2, 3], [3, 2], [4, 1]]

所以5是最受欢迎的项目,有9个出场。

1
2
>>> freq_table(my_sentence)
[[ '' , 9], [ '一种' , 7], [ 'e' , 5], [ 't' , 4], [ 'n' , 3], [ 'd' , 2], [ 'H' , 2], [ 'p' , 2], [, 2], [ 'r' , 2], [ 'C' , 1], [ 'm' , 1], [ 'o' , 1], [ 'T' , 1], [ 'w' , 1]]

因此,空间是最受欢迎的,其次是a,e和t。