相关疑难解决方法(0)

假设你有一系列2元组:

seq_of_tups = (('a', 1), ('b', 2), ('c', 3))

并且您想测试if 'a'是序列中任何元组的第一项.

什么是最恐怖的方式？

转换为字典并测试密钥,这似乎很容易理解？即

'a' in dict(seq_of_tups)

使用可爱的拉链技巧,除非你知道这个技巧,否则不是特别清楚？即

'a' in zip(*seq_of_tups)[0]

或者真的明确地图？即

'a' in map(lambda tup: tup[0], seq_of_tups)

还是有比这些选择更好的方法？

在下面的简单示例中,有两个函数可以对随机数列表进行排序.第一种方法传递sorted生成器表达式,第二种方法首先创建一个列表:

import random
l = [int(1000*random.random()) for i in xrange(10*6)]

def sort_with_generator():
    return sorted(a for a in l)

def sort_with_list():
    return sorted([a for a in l])

使用行分析器进行基准测试表明第二个选项(sort_with_list)的速度大约是生成器表达式的两倍.

任何人都可以解释发生了什么,为什么第一种方法比第二种方法慢得多？

我有这样的示例列表:

example_list = [['aaa'], ['fff', 'gg'], ['ff'], ['', 'gg']]

现在,我检查它是否有这样的空字符串:

has_empty = False;
for list1 in example_list:
    for val1 in list1:
        if val1 == '':
            has_empty = True

print(has_empty)

这可以正常,因为它打印True,但寻找更多的pythonik方法？

在main.py我有这个

import RemoveShortWords as rs

procLine="the   in  shear flow past a flat plate"
procLine = rs.RemomeOneTwoCharWords(procLine)
print(procLine)

而RemoveShortWords.py这是

def RemomeOneTwoCharWords(procLine):

    procLine = str(procLine)

    for word in procLine.split():

        if(len(word)<=2):
            procLine = procLine.replace(word,"")


    return procLine

print返回此信息

sher flow pst flt plte

正如您所看到的,函数会删除少于2个字符的单词.但是,出于某种原因,它也删除了所有"a"字符.例如,"flat"变成了"flt"

为什么？

据我所知，当我们只想使用这些值一次时，我们可以使用生成器。使用下面的 2 个示例，我的逻辑是第二个应该更快，因为第一个首先创建一个列表，然后循环遍历值..而第二个仅处理来自生成器的值。然而，当我计算时间时，列表理解总是比生成器更快。为什么是这样？

第一：

x = []
a = time.perf_counter()
for j in [i**2 for i in range(20000)]:
    x.append(j)
print( time.perf_counter() - a )

第二：

x = []
a = time.perf_counter()
for j in (i**2 for i in range(20000)):
    x.append(j)
print( time.perf_counter() - a )

我有一个3元素的python元组,我正在尝试使用3元素列表的索引进行排序或重新排列,我想知道最简洁的方法是什么.

到目前为止我有:

my_tuple = (10, 20, 30)
new_positions = [2, 0, 1]
my_shuffled_tuple = my_tuple[new_positions[0]], my_tuple[new_positions[1]], my_tuple[new_positions[2]]
# outputs: (30, 10, 20)

如果我这样做,我也得到相同的结果:

my_shuffled_tuple = tuple([my_tuple[i] for i in new_positions])

是否有更简洁的创作方式my_shuffled_tuple？

假设我有这样的字典:

docDict = {"alpha": ["a", "b", "c", "a", "b"], "bravo": ["b", "c", "d", "c", "d"]}

而我想要做的就像计算"文档频率":假设每个字典项都是一个文档,我有一个特定的单词,那么有多少文档包含该单词？

我看过很多帖子告诉我如何计算频率,但是如果"a"在文档中出现两次"alpha",我只需要计数为1.所以"频率" "a"应该是1,"c"应该是2.

我知道我可以迭代整个文档字典,并在文档中找到单词时添加计数器.或者我可以首先使每个文档中的单词都是唯一的,然后组合所有文档并计算单词.

但我认为有更好的方法,更有效的方式.有任何想法吗？

顺便说一下,有什么方法可以保持字典的结构吗？在这个例子中,我想得到一个结果{"alpha": {'c': 2, 'b': 2, 'a': 1}, "bravo": {'c': 2, 'b': 2, 'd': 1}

更新

如果在这里我只有一个列表(类似的东西[["a", "b", "c", "a", "b"], ["b", "c", "d", "c", "d"]]),我怎么能得到像这样的结果列表[[1, 2, 2, 0], [0, 2, 2, 1]].

我不知道.关键是要扩展每个列表并确保术语的顺序.思考？

在下面的代码中,使用列表推导还是生成器更好？

from itertools import izip
n=2
l=izip(xrange(10**n), xrange(10**n))
print 3 not in [x[0] for x in l]
#or
#print 3 not in (x[0] for x in l)

在这些测试中,如果列表很大,则生成器更快,如果列表更短,则列表理解显然更快.
这是因为理解只是计算机一次吗？
对于大型列表:生成器比listcomp更快
对于小型列表:生成器比listcomp慢

我有一个如下所示的列表:

List = [['name1','surname1'], ['name2','surname2'],['name3','surname3']]

我想检查"name1"是否在对象"List"中.我试过了:

if 'name1' in List:
    print True
else:
    print False

输出为'False'.知道如何创建一个子列表(或类似的东西)来检查每个子列表的第一个元素而不循环遍历主列表的所有元素？

可能的解决方案

我想到的是:

for i in range(0, len(List)):
    if List[i][0] == 'name1':
        print True

但是如果可能的话,我希望尽可能避免使用更优化的迭代.

如何检查Python列表中的特定对象类型？例如,我想ast在列表l中检查模块对象Subscript或_ast.Subscript:

if Subscript in l:
    return True

但这还没有奏效.任何有关此问题的帮助将不胜感激.

对象也在0x7ff7f7f7f7ff>处打印为<_ast.Subscript对象